diff --git a/ICSharpCode.Decompiler.Tests/Helpers/RemoveCompilerAttribute.cs b/ICSharpCode.Decompiler.Tests/Helpers/RemoveCompilerAttribute.cs index 3e71a38b7..3231e7f96 100644 --- a/ICSharpCode.Decompiler.Tests/Helpers/RemoveCompilerAttribute.cs +++ b/ICSharpCode.Decompiler.Tests/Helpers/RemoveCompilerAttribute.cs @@ -6,9 +6,9 @@ using ICSharpCode.Decompiler.TypeSystem; namespace ICSharpCode.Decompiler.Tests.Helpers { - class RemoveCompilerAttribute : DepthFirstAstVisitor, IAstTransform + class RemoveCompilerAttribute : DepthFirstAstVisitor, IAstTransform { - public override object VisitAttribute(CSharp.Syntax.Attribute attribute, object data) + public override void VisitAttribute(CSharp.Syntax.Attribute attribute) { var section = (AttributeSection)attribute.Parent; SimpleType type = attribute.Type as SimpleType; @@ -25,16 +25,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers if (section.Attributes.Count == 0) section.Remove(); } - return null; } public void Run(AstNode rootNode, TransformContext context) { - rootNode.AcceptVisitor(this, null); + rootNode.AcceptVisitor(this); } } - public class RemoveEmbeddedAtttributes : DepthFirstAstVisitor, IAstTransform + public class RemoveEmbeddedAtttributes : DepthFirstAstVisitor, IAstTransform { HashSet attributeNames = new HashSet() { "System.Runtime.CompilerServices.IsReadOnlyAttribute", @@ -42,21 +41,20 @@ namespace ICSharpCode.Decompiler.Tests.Helpers "Microsoft.CodeAnalysis.EmbeddedAttribute", }; - public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) + public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration) { var typeDefinition = typeDeclaration.GetSymbol() as ITypeDefinition; if (typeDefinition == null || !attributeNames.Contains(typeDefinition.FullName)) - return null; + return; if (typeDeclaration.Parent is NamespaceDeclaration ns && ns.Members.Count == 1) ns.Remove(); else typeDeclaration.Remove(); - return null; } public void Run(AstNode rootNode, TransformContext context) { - rootNode.AcceptVisitor(this, null); + rootNode.AcceptVisitor(this); } } } diff --git a/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs b/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs index 7e65ba05a..f7927ac17 100644 --- a/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs +++ b/ICSharpCode.Decompiler.Tests/Helpers/Tester.cs @@ -110,7 +110,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers { if (asmOptions.HasFlag(AssemblerOptions.UseOwnDisassembler)) { using (ModuleDefinition module = ModuleDefinition.ReadModule(sourceFileName)) - using (var writer = new StreamWriter(outputFile)) { + using (var writer = new StringWriter()) { module.Name = Path.GetFileNameWithoutExtension(outputFile); var output = new PlainTextOutput(writer); ReflectionDisassembler rd = new ReflectionDisassembler(output, CancellationToken.None); @@ -122,6 +122,8 @@ namespace ICSharpCode.Decompiler.Tests.Helpers rd.WriteModuleHeader(module, skipMVID: true); output.WriteLine(); rd.WriteModuleContents(module); + + File.WriteAllText(outputFile, ReplacePrivImplDetails(writer.ToString())); } return outputFile; } @@ -157,11 +159,17 @@ namespace ICSharpCode.Decompiler.Tests.Helpers il = Regex.Replace(il, @"^// +Copyright .* Microsoft.*\r?\n", "", RegexOptions.Multiline); // filename may contain full path il = Regex.Replace(il, @"^// WARNING: Created Win32 resource file.*\r?\n", "", RegexOptions.Multiline); + il = ReplacePrivImplDetails(il); File.WriteAllText(outputFile, il); return outputFile; } + private static string ReplacePrivImplDetails(string il) + { + return Regex.Replace(il, @"'\{[0-9A-F-]+\}'", "''"); + } + static readonly Lazy> defaultReferences = new Lazy>(delegate { string refAsmPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5"); @@ -170,7 +178,8 @@ namespace ICSharpCode.Decompiler.Tests.Helpers MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "mscorlib.dll")), MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "System.dll")), MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "System.Core.dll")), - MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "System.Xml.dll")) + MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "System.Xml.dll")), + MetadataReference.CreateFromFile(typeof(ValueTuple).Assembly.Location) }; }); diff --git a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj index da41f0e6d..9e0f63b49 100644 --- a/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj +++ b/ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj @@ -37,8 +37,8 @@ - - + + @@ -62,13 +62,17 @@ + + + + @@ -81,6 +85,7 @@ + diff --git a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs index 6abcf5620..73b843890 100644 --- a/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/ILPrettyTestRunner.cs @@ -94,6 +94,24 @@ namespace ICSharpCode.Decompiler.Tests Run(settings: new DecompilerSettings { RemoveDeadCode = true }); } + [Test] + public void CS1xSwitch_Debug() + { + Run(); + } + + [Test] + public void CS1xSwitch_Release() + { + Run(); + } + + [Test] + public void Issue1145() + { + Run(); + } + [Test, Ignore("?")] public void FSharpLoops_Debug() { diff --git a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs index 3eb4a63c0..f80cc3498 100644 --- a/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs @@ -279,6 +279,12 @@ namespace ICSharpCode.Decompiler.Tests RunForLibrary(cscOptions: cscOptions); } + [Test] + public void TupleTests([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions) + { + RunForLibrary(cscOptions: cscOptions); + } + [Test] public void Issue1080([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions) { diff --git a/ICSharpCode.Decompiler.Tests/Semantics/ConversionTests.cs b/ICSharpCode.Decompiler.Tests/Semantics/ConversionTests.cs new file mode 100644 index 000000000..c59e84f6e --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/Semantics/ConversionTests.cs @@ -0,0 +1,1507 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.Immutable; +using ICSharpCode.Decompiler.CSharp.Resolver; +using ICSharpCode.Decompiler.Semantics; +using ICSharpCode.Decompiler.Tests.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using NUnit.Framework; + +namespace ICSharpCode.Decompiler.Tests.Semantics +{ + // assign short names to the fake reflection types + using Null = ICSharpCode.Decompiler.TypeSystem.ReflectionHelper.Null; + using dynamic = ICSharpCode.Decompiler.TypeSystem.ReflectionHelper.Dynamic; + using C = Conversion; + + [TestFixture, Parallelizable(ParallelScope.All)] + public unsafe class ConversionTest + { + CSharpConversions conversions; + ICompilation compilation; + + [OneTimeSetUp] + public void SetUp() + { + compilation = new SimpleCompilation(TypeSystemLoaderTests.TestAssembly, + TypeSystemLoaderTests.Mscorlib, + TypeSystemLoaderTests.SystemCore); + conversions = new CSharpConversions(compilation); + } + + Conversion ImplicitConversion(Type from, Type to) + { + IType from2 = compilation.FindType(from); + IType to2 = compilation.FindType(to); + return conversions.ImplicitConversion(from2, to2); + } + + [Test] + public void IdentityConversions() + { + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(char), typeof(char))); + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(string), typeof(string))); + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(object), typeof(object))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(bool), typeof(char))); + + Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion(SpecialType.Dynamic, SpecialType.Dynamic)); + Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion(SpecialType.UnknownType, SpecialType.UnknownType)); + Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion(SpecialType.NullType, SpecialType.NullType)); + } + + [Test] + public void DynamicIdentityConversions() + { + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(object), typeof(dynamic))); + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(dynamic), typeof(object))); + } + + [Test] + public void ComplexDynamicIdentityConversions() + { + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(List), typeof(List))); + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(List), typeof(List))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(List), typeof(List))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(List), typeof(List))); + + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(List[]>), typeof(List[]>))); + Assert.AreEqual(C.IdentityConversion, ImplicitConversion(typeof(List[]>), typeof(List[]>))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(List[,]>), typeof(List[]>))); + } + + [Test] + public void TupleIdentityConversions() + { + var intType = compilation.FindType(typeof(int)); + var stringType = compilation.FindType(typeof(string)); + Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion( + new TupleType(compilation, ImmutableArray.Create(intType, stringType), ImmutableArray.Create("a", "b")), + new TupleType(compilation, ImmutableArray.Create(intType, stringType), ImmutableArray.Create("a", "c")))); + + Assert.AreEqual(C.None, conversions.ImplicitConversion( + new TupleType(compilation, ImmutableArray.Create(intType, stringType), ImmutableArray.Create("a", "b")), + new TupleType(compilation, ImmutableArray.Create(stringType, intType), ImmutableArray.Create("a", "b")))); + } + + [Test] + public void TupleConversions() + { + Assert.AreEqual( + C.TupleConversion(ImmutableArray.Create(C.ImplicitNumericConversion, C.ImplicitReferenceConversion)), + ImplicitConversion(typeof((int, string)), typeof((long, object)))); + + Assert.AreEqual( + C.TupleConversion(ImmutableArray.Create(C.ImplicitNumericConversion)), + ImplicitConversion(typeof(ValueTuple), typeof(ValueTuple))); + } + + [Test] + public void PrimitiveConversions() + { + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(char), typeof(ushort))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(byte), typeof(char))); + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(int), typeof(long))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(long), typeof(int))); + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(int), typeof(float))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(bool), typeof(float))); + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(float), typeof(double))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(float), typeof(decimal))); + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(char), typeof(long))); + Assert.AreEqual(C.ImplicitNumericConversion, ImplicitConversion(typeof(uint), typeof(long))); + } + + [Test] + public void EnumerationConversion() + { + ResolveResult zero = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 0); + ResolveResult one = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 1); + C implicitEnumerationConversion = C.EnumerationConversion(true, false); + Assert.AreEqual(implicitEnumerationConversion, conversions.ImplicitConversion(zero, compilation.FindType(typeof(StringComparison)))); + Assert.AreEqual(C.None, conversions.ImplicitConversion(one, compilation.FindType(typeof(StringComparison)))); + } + + [Test] + public void NullableConversions() + { + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(char), typeof(ushort?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(byte), typeof(char?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(int), typeof(long?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(long), typeof(int?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(int), typeof(float?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(bool), typeof(float?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(float), typeof(double?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(float), typeof(decimal?))); + } + + [Test] + public void NullableConversions2() + { + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(char?), typeof(ushort?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(byte?), typeof(char?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(int?), typeof(long?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(long?), typeof(int?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(int?), typeof(float?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(bool?), typeof(float?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ImplicitConversion(typeof(float?), typeof(double?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(float?), typeof(decimal?))); + } + + [Test] + public void NullLiteralConversions() + { + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(int?))); + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(char?))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(Null), typeof(int))); + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(object))); + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(dynamic))); + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(string))); + Assert.AreEqual(C.NullLiteralConversion, ImplicitConversion(typeof(Null), typeof(int[]))); + } + + [Test] + public void SimpleReferenceConversions() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string), typeof(object))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(BitArray), typeof(ICollection))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(IList), typeof(IEnumerable))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(object), typeof(string))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(ICollection), typeof(BitArray))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(IEnumerable), typeof(IList))); + } + + [Test] + public void ConversionToDynamic() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string), typeof(dynamic))); + Assert.AreEqual(C.BoxingConversion, ImplicitConversion(typeof(int), typeof(dynamic))); + } + + [Test] + public void ConversionFromDynamic() + { + // There is no conversion from the type 'dynamic' to other types (except the identity conversion to object). + // Such conversions only exists from dynamic expression. + // This is an important distinction for type inference (see TypeInferenceTests.IEnumerableCovarianceWithDynamic) + Assert.AreEqual(C.None, ImplicitConversion(typeof(dynamic), typeof(string))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(dynamic), typeof(int))); + + var dynamicRR = new ResolveResult(SpecialType.Dynamic); + Assert.AreEqual(C.ImplicitDynamicConversion, conversions.ImplicitConversion(dynamicRR, compilation.FindType(typeof(string)))); + Assert.AreEqual(C.ImplicitDynamicConversion, conversions.ImplicitConversion(dynamicRR, compilation.FindType(typeof(int)))); + } + + [Test] + public void ParameterizedTypeConversions() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(List), typeof(ICollection))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(IList), typeof(ICollection))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(List), typeof(ICollection))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(IList), typeof(ICollection))); + } + + [Test] + public void ArrayConversions() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[]), typeof(object[]))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[,]), typeof(object[,]))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(string[]), typeof(object[,]))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(object[]), typeof(string[]))); + + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[]), typeof(IList))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(string[,]), typeof(IList))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[]), typeof(IList))); + + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[]), typeof(Array))); + Assert.AreEqual(C.ImplicitReferenceConversion, ImplicitConversion(typeof(string[]), typeof(ICloneable))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(Array), typeof(string[]))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(object), typeof(object[]))); + } + + [Test] + public void VarianceConversions() + { + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(List), typeof(IEnumerable))); + Assert.AreEqual(C.None, + ImplicitConversion(typeof(List), typeof(IEnumerable))); + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + Assert.AreEqual(C.None, + ImplicitConversion(typeof(ICollection), typeof(ICollection))); + + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(Comparer), typeof(IComparer))); + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(Comparer), typeof(IComparer))); + Assert.AreEqual(C.None, + ImplicitConversion(typeof(Comparer), typeof(Comparer))); + + Assert.AreEqual(C.None, + ImplicitConversion(typeof(List), typeof(IEnumerable))); + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.ImplicitReferenceConversion, + ImplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.None, + ImplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.None, + ImplicitConversion(typeof(Func), typeof(Func))); + } + + [Test] + public void ImplicitPointerConversion() + { + Assert.AreEqual(C.ImplicitPointerConversion, ImplicitConversion(typeof(Null), typeof(int*))); + Assert.AreEqual(C.ImplicitPointerConversion, ImplicitConversion(typeof(int*), typeof(void*))); + } + + [Test] + public void NoConversionFromPointerTypeToObject() + { + Assert.AreEqual(C.None, ImplicitConversion(typeof(int*), typeof(object))); + Assert.AreEqual(C.None, ImplicitConversion(typeof(int*), typeof(dynamic))); + } + + [Test] + public void UnconstrainedTypeParameter() + { + ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T"); + ITypeParameter t2 = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 1, "T2"); + ITypeParameter tm = new DefaultTypeParameter(compilation, SymbolKind.Method, 0, "TM"); + + Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); + Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); + Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); + + Assert.AreEqual(C.IdentityConversion, conversions.ImplicitConversion(t, t)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t2, t)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, t2)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, tm)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(tm, t)); + } + + [Test] + public void TypeParameterWithReferenceTypeConstraint() + { + ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasReferenceTypeConstraint: true); + + Assert.AreEqual(C.NullLiteralConversion, conversions.ImplicitConversion(SpecialType.NullType, t)); + Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); + Assert.AreEqual(C.ImplicitReferenceConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); + } + + [Test] + public void TypeParameterWithValueTypeConstraint() + { + ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", hasValueTypeConstraint: true); + + Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); + Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); + Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, SpecialType.Dynamic)); + Assert.AreEqual(C.BoxingConversion, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); + } + + [Test] + public void TypeParameterWithClassConstraint() + { + ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", + constraints: new[] { compilation.FindType(typeof(StringComparer)) }); + + Assert.AreEqual(C.NullLiteralConversion, + conversions.ImplicitConversion(SpecialType.NullType, t)); + Assert.AreEqual(C.ImplicitReferenceConversion, + conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); + Assert.AreEqual(C.ImplicitReferenceConversion, + conversions.ImplicitConversion(t, SpecialType.Dynamic)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); + Assert.AreEqual(C.ImplicitReferenceConversion, + conversions.ImplicitConversion(t, compilation.FindType(typeof(StringComparer)))); + Assert.AreEqual(C.ImplicitReferenceConversion, + conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer)))); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer)))); + Assert.AreEqual(C.ImplicitReferenceConversion, + conversions.ImplicitConversion(t, compilation.FindType(typeof(IComparer)))); + } + + [Test] + public void TypeParameterWithInterfaceConstraint() + { + ITypeParameter t = new DefaultTypeParameter(compilation, SymbolKind.TypeDefinition, 0, "T", + constraints: new[] { compilation.FindType(typeof(IList)) }); + + Assert.AreEqual(C.None, conversions.ImplicitConversion(SpecialType.NullType, t)); + Assert.AreEqual(C.BoxingConversion, + conversions.ImplicitConversion(t, compilation.FindType(KnownTypeCode.Object))); + Assert.AreEqual(C.BoxingConversion, + conversions.ImplicitConversion(t, SpecialType.Dynamic)); + Assert.AreEqual(C.None, conversions.ImplicitConversion(t, compilation.FindType(typeof(ValueType)))); + Assert.AreEqual(C.BoxingConversion, + conversions.ImplicitConversion(t, compilation.FindType(typeof(IList)))); + Assert.AreEqual(C.BoxingConversion, + conversions.ImplicitConversion(t, compilation.FindType(typeof(IEnumerable)))); + } + + [Test] + public void UserDefinedImplicitConversion() + { + Conversion c = ImplicitConversion(typeof(DateTime), typeof(DateTimeOffset)); + Assert.IsTrue(c.IsImplicit && c.IsUserDefined); + Assert.AreEqual("System.DateTimeOffset.op_Implicit", c.Method.FullName); + + Assert.AreEqual(C.None, ImplicitConversion(typeof(DateTimeOffset), typeof(DateTime))); + } + + [Test] + public void UserDefinedImplicitNullableConversion() + { + // User-defined conversion followed by nullable conversion + Conversion c = ImplicitConversion(typeof(DateTime), typeof(DateTimeOffset?)); + Assert.IsTrue(c.IsValid && c.IsUserDefined); + Assert.IsFalse(c.IsLifted); + // Lifted user-defined conversion + c = ImplicitConversion(typeof(DateTime?), typeof(DateTimeOffset?)); + Assert.IsTrue(c.IsValid && c.IsUserDefined && c.IsLifted); + // User-defined conversion doesn't drop the nullability + c = ImplicitConversion(typeof(DateTime?), typeof(DateTimeOffset)); + Assert.IsFalse(c.IsValid); + } + + bool IntegerLiteralConversion(object value, Type to) + { + IType fromType = compilation.FindType(value.GetType()); + ConstantResolveResult crr = new ConstantResolveResult(fromType, value); + IType to2 = compilation.FindType(to); + return conversions.ImplicitConversion(crr, to2).IsValid; + } + + [Test] + public void IntegerLiteralToEnumConversions() + { + Assert.IsTrue(IntegerLiteralConversion(0, typeof(LoaderOptimization))); + Assert.IsTrue(IntegerLiteralConversion(0L, typeof(LoaderOptimization))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(LoaderOptimization?))); + Assert.IsFalse(IntegerLiteralConversion(0, typeof(string))); + Assert.IsFalse(IntegerLiteralConversion(1, typeof(LoaderOptimization))); + } + + [Test] + public void ImplicitConstantExpressionConversion() + { + Assert.IsTrue(IntegerLiteralConversion(0, typeof(int))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(ushort))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(sbyte))); + + Assert.IsTrue(IntegerLiteralConversion(-1, typeof(int))); + Assert.IsFalse(IntegerLiteralConversion(-1, typeof(ushort))); + Assert.IsTrue(IntegerLiteralConversion(-1, typeof(sbyte))); + + Assert.IsTrue(IntegerLiteralConversion(200, typeof(int))); + Assert.IsTrue(IntegerLiteralConversion(200, typeof(ushort))); + Assert.IsFalse(IntegerLiteralConversion(200, typeof(sbyte))); + } + + [Test] + public void ImplicitLongConstantExpressionConversion() + { + Assert.IsFalse(IntegerLiteralConversion(0L, typeof(int))); + Assert.IsFalse(IntegerLiteralConversion(0L, typeof(short))); + Assert.IsTrue(IntegerLiteralConversion(0L, typeof(long))); + Assert.IsTrue(IntegerLiteralConversion(0L, typeof(ulong))); + + Assert.IsTrue(IntegerLiteralConversion(-1L, typeof(long))); + Assert.IsFalse(IntegerLiteralConversion(-1L, typeof(ulong))); + } + + [Test] + public void ImplicitConstantExpressionConversionToNullable() + { + Assert.IsTrue(IntegerLiteralConversion(0, typeof(uint?))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(short?))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(byte?))); + + Assert.IsFalse(IntegerLiteralConversion(-1, typeof(uint?))); + Assert.IsTrue(IntegerLiteralConversion(-1, typeof(short?))); + Assert.IsFalse(IntegerLiteralConversion(-1, typeof(byte?))); + + Assert.IsTrue(IntegerLiteralConversion(200, typeof(uint?))); + Assert.IsTrue(IntegerLiteralConversion(200, typeof(short?))); + Assert.IsTrue(IntegerLiteralConversion(200, typeof(byte?))); + + Assert.IsFalse(IntegerLiteralConversion(0L, typeof(uint?))); + Assert.IsTrue(IntegerLiteralConversion(0L, typeof(long?))); + Assert.IsTrue(IntegerLiteralConversion(0L, typeof(ulong?))); + + Assert.IsTrue(IntegerLiteralConversion(-1L, typeof(long?))); + Assert.IsFalse(IntegerLiteralConversion(-1L, typeof(ulong?))); + } + + [Test] + public void ImplicitConstantExpressionConversionNumberInterfaces() + { + Assert.IsTrue(IntegerLiteralConversion(0, typeof(IFormattable))); + Assert.IsTrue(IntegerLiteralConversion(0, typeof(IComparable))); + Assert.IsFalse(IntegerLiteralConversion(0, typeof(IComparable))); + Assert.IsFalse(IntegerLiteralConversion(0, typeof(IComparable))); + } + + int BetterConversion(Type s, Type t1, Type t2) + { + IType sType = compilation.FindType(s); + IType t1Type = compilation.FindType(t1); + IType t2Type = compilation.FindType(t2); + return conversions.BetterConversion(sType, t1Type, t2Type); + } + + int BetterConversion(object value, Type t1, Type t2) + { + IType fromType = compilation.FindType(value.GetType()); + ConstantResolveResult crr = new ConstantResolveResult(fromType, value); + IType t1Type = compilation.FindType(t1); + IType t2Type = compilation.FindType(t2); + return conversions.BetterConversion(crr, t1Type, t2Type); + } + + [Test] + public void BetterConversion() + { + Assert.AreEqual(1, BetterConversion(typeof(string), typeof(string), typeof(object))); + Assert.AreEqual(2, BetterConversion(typeof(string), typeof(object), typeof(IComparable))); + Assert.AreEqual(0, BetterConversion(typeof(string), typeof(IEnumerable), typeof(IComparable))); + } + + [Test] + public void BetterPrimitiveConversion() + { + Assert.AreEqual(1, BetterConversion(typeof(short), typeof(int), typeof(long))); + Assert.AreEqual(1, BetterConversion(typeof(short), typeof(int), typeof(uint))); + Assert.AreEqual(2, BetterConversion(typeof(ushort), typeof(uint), typeof(int))); + Assert.AreEqual(1, BetterConversion(typeof(char), typeof(short), typeof(int))); + Assert.AreEqual(1, BetterConversion(typeof(char), typeof(ushort), typeof(int))); + Assert.AreEqual(1, BetterConversion(typeof(sbyte), typeof(long), typeof(ulong))); + Assert.AreEqual(2, BetterConversion(typeof(byte), typeof(ushort), typeof(short))); + + Assert.AreEqual(1, BetterConversion(1, typeof(sbyte), typeof(byte))); + Assert.AreEqual(2, BetterConversion(1, typeof(ushort), typeof(sbyte))); + } + + [Test] + public void BetterNullableConversion() + { + Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(int), typeof(uint?))); + Assert.AreEqual(0, BetterConversion(typeof(byte?), typeof(int?), typeof(uint?))); + Assert.AreEqual(1, BetterConversion(typeof(byte), typeof(ushort?), typeof(uint?))); + Assert.AreEqual(2, BetterConversion(typeof(byte?), typeof(ulong?), typeof(uint?))); + Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ushort?), typeof(uint))); + Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ushort?), typeof(int))); + Assert.AreEqual(2, BetterConversion(typeof(byte), typeof(ulong?), typeof(uint))); + Assert.AreEqual(0, BetterConversion(typeof(byte), typeof(ulong?), typeof(int))); + Assert.AreEqual(2, BetterConversion(typeof(ushort?), typeof(long?), typeof(int?))); + Assert.AreEqual(0, BetterConversion(typeof(sbyte), typeof(int?), typeof(uint?))); + } + + [Test] + public void ExpansiveInheritance() + { + var a = new DefaultUnresolvedTypeDefinition(string.Empty, "A"); + var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B"); + // interface A + a.Kind = TypeKind.Interface; + a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "U") { Variance = VarianceModifier.Contravariant }); + // interface B : A>> { } + b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X")); + b.BaseTypes.Add(new ParameterizedTypeReference( + a, new[] { new ParameterizedTypeReference( + a, new [] { new ParameterizedTypeReference( + b, new [] { new TypeParameterReference(SymbolKind.TypeDefinition, 0) } + ) } ) })); + + ICompilation compilation = TypeSystemHelper.CreateCompilation(a, b); + ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a.FullTypeName); + ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b.FullTypeName); + + IType type1 = new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.Double) }); + IType type2 = new ParameterizedType(resolvedA, new[] { new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.String) }) }); + Assert.IsFalse(conversions.ImplicitConversion(type1, type2).IsValid); + } + + /* TODO: we should probably revive these tests somehow + [Test] + public void ImplicitTypeParameterConversion() + { + string program = @"using System; +class Test { + public void M(T t) where T : U { + U u = $t$; + } +}"; + Assert.AreEqual(C.BoxingConversion, GetConversion(program)); + } + + [Test] + public void InvalidImplicitTypeParameterConversion() + { + string program = @"using System; +class Test { + public void M(T t) where U : T { + U u = $t$; + } +}"; + Assert.AreEqual(C.None, GetConversion(program)); + } + + [Test] + public void ImplicitTypeParameterArrayConversion() + { + string program = @"using System; +class Test { + public void M(T[] t) where T : U { + U[] u = $t$; + } +}"; + // invalid, e.g. T=int[], U=object[] + Assert.AreEqual(C.None, GetConversion(program)); + } + + [Test] + public void ImplicitTypeParameterConversionWithClassConstraint() + { + string program = @"using System; +class Test { + public void M(T t) where T : class, U where U : class { + U u = $t$; + } +}"; + Assert.AreEqual(C.ImplicitReferenceConversion, GetConversion(program)); + } + + [Test] + public void ImplicitTypeParameterArrayConversionWithClassConstraint() + { + string program = @"using System; +class Test { + public void M(T[] t) where T : class, U where U : class { + U[] u = $t$; + } +}"; + Assert.AreEqual(C.ImplicitReferenceConversion, GetConversion(program)); + } + + [Test] + public void ImplicitTypeParameterConversionWithClassConstraintOnlyOnT() + { + string program = @"using System; +class Test { + public void M(T t) where T : class, U { + U u = $t$; + } +}"; + Assert.AreEqual(C.ImplicitReferenceConversion, GetConversion(program)); + } + + [Test] + public void ImplicitTypeParameterArrayConversionWithClassConstraintOnlyOnT() + { + string program = @"using System; +class Test { + public void M(T[] t) where T : class, U { + U[] u = $t$; + } +}"; + Assert.AreEqual(C.ImplicitReferenceConversion, GetConversion(program)); + } + + [Test] + public void MethodGroupConversion_Void() + { + string program = @"using System; +delegate void D(); +class Test { + D d = $M$; + public static void M() {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.IsFalse(c.DelegateCapturesFirstArgument); + Assert.IsNotNull(c.Method); + } + + [Test] + public void MethodGroupConversion_Void_InstanceMethod() + { + string program = @"using System; +delegate void D(); +class Test { + D d; + public void M() { + d = $M$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.IsTrue(c.DelegateCapturesFirstArgument); + Assert.IsNotNull(c.Method); + } + + [Test] + public void MethodGroupConversion_MatchingSignature() + { + string program = @"using System; +delegate object D(int argument); +class Test { + D d = $M$; + public static object M(int argument) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_InvalidReturnType() + { + string program = @"using System; +delegate object D(int argument); +class Test { + D d = $M$; + public static int M(int argument) {} +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_CovariantReturnType() + { + string program = @"using System; +delegate object D(int argument); +class Test { + D d = $M$; + public static string M(int argument) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_RefArgumentTypesEqual() + { + string program = @"using System; +delegate void D(ref object o); +class Test { + D d = $M$; + public static void M(ref object o) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_RefArgumentObjectVsDynamic() + { + string program = @"using System; +delegate void D(ref object o); +class Test { + D d = $M$; + public static void M(ref dynamic o) {} +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_RefVsOut() + { + string program = @"using System; +delegate void D(ref object o); +class Test { + D d = $M$; + public static void M(out object o) {} +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void MethodGroupConversion_RefVsNormal() + { + string program = @"using System; +delegate void D(ref object o); +class Test { + D d = $M$; + public static void M(object o) {} +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void MethodGroupConversion_NormalVsOut() + { + string program = @"using System; +delegate void D(object o); +class Test { + D d = $M$; + public static void M(out object o) {} +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void MethodGroupConversion_MatchingNormalParameter() + { + string program = @"using System; +delegate void D(object o); +class Test { + D d = $M$; + public static void M(object o) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_IdentityConversion() + { + string program = @"using System; +delegate void D(object o); +class Test { + D d = $M$; + public static void M(dynamic o) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_Contravariance() + { + string program = @"using System; +delegate void D(string o); +class Test { + D d = $M$; + public static void M(object o) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + + } + + [Test, Ignore("Not sure if this conversion should be valid or not... NR and mcs both accept it as valid, csc treats it as invalid")] + public void MethodGroupConversion_NoContravarianceDynamic() + { + string program = @"using System; +delegate void D(string o); +class Test { + D d = $M$; + public static void M(dynamic o) {} +}"; + var c = GetConversion(program); + //Assert.IsFrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + } + + [Test] + public void MethodGroupConversion_ExactMatchIsBetter() + { + string program = @"using System; +class Test { + delegate void D(string a); + D d = $M$; + static void M(object x) {} + static void M(string x = null) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.AreEqual("System.String", c.Method.Parameters.Single().Type.FullName); + } + + [Test] + public void MethodGroupConversion_CannotLeaveOutOptionalParameters() + { + string program = @"using System; +class Test { + delegate void D(string a); + D d = $M$; + static void M(object x) {} + static void M(string x, string y = null) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.AreEqual("System.Object", c.Method.Parameters.Single().Type.FullName); + } + + [Test] + public void MethodGroupConversion_CannotUseExpandedParams() + { + string program = @"using System; +class Test { + delegate void D(string a); + D d = $M$; + static void M(object x) {} + static void M(params string[] x) {} +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.AreEqual("System.Object", c.Method.Parameters.Single().Type.FullName); + } + + [Test] + public void MethodGroupConversion_ExtensionMethod() + { + string program = @"using System; +static class Ext { + public static void M(this string s, int x) {} +} +class Test { + delegate void D(int a); + void F() { + string s = """"; + D d = $s.M$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.IsTrue(c.DelegateCapturesFirstArgument); + } + + [Test] + public void MethodGroupConversion_ExtensionMethodUsedAsStaticMethod() + { + string program = @"using System; +static class Ext { + public static void M(this string s, int x) {} +} +class Test { + delegate void D(string s, int a); + void F() { + D d = $Ext.M$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsMethodGroupConversion); + Assert.IsFalse(c.DelegateCapturesFirstArgument); + } + + [Test] + public void MethodGroupConversion_ObjectToDynamic() + { + string program = @"using System; +class Test { + public void F(object o) {} + public void M() { + Action x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void MethodGroupConversion_ObjectToDynamicGenericArgument() + { + string program = @"using System; +using System.Collections.Generic; +class Test { + public void F(List l) {} + public void M() { + Action> x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void MethodGroupConversion_ObjectToDynamicReturnValue() + { + string program = @"using System; +class Test { + public object F() {} + public void M() { + Func x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void MethodGroupConversion_DynamicToObject() + { + string program = @"using System; +class Test { + public void F(dynamic o) {} + public void M() { + Action x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void MethodGroupConversion_DynamicToObjectGenericArgument() + { + string program = @"using System; +using System.Collections.Generic; +class Test { + public void F(List l) {} + public void M() { + Action> x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void MethodGroupConversion_DynamicToObjectReturnValue() + { + string program = @"using System; +class Test { + public dynamic F() {} + public void M() { + Func x = $F$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + } + + [Test] + public void UserDefined_IntLiteral_ViaUInt_ToCustomStruct() + { + string program = @"using System; +struct T { + public static implicit operator T(uint a) { return new T(); } +} +class Test { + static void M() { + T t = $1$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + } + + [Test] + public void UserDefined_NullLiteral_ViaString_ToCustomStruct() + { + string program = @"using System; +struct T { + public static implicit operator T(string a) { return new T(); } + +} +class Test { + static void M() { + T t = $null$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + } + + + [Test] + public void UserDefined_CanUseLiftedEvenIfReturnTypeAlreadyNullable() + { + string program = @"using System; +struct S { + public static implicit operator short?(S s) { return 0; } +} + +class Test { + static void M(S? s) { + int? i = $s$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.IsTrue(c.IsLifted); + } + + [Test] + public void UserDefinedImplicitConversion_PicksExactSourceTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(int i) {return new Convertible(); } + public static implicit operator Convertible(short s) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $33$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("i", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_PicksMostEncompassedSourceType() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(long l) {return new Convertible(); } + public static implicit operator Convertible(uint ui) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $(ushort)33$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("ui", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_NoMostEncompassedSourceTypeIsInvalid() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(ulong l) {return new Convertible(); } + public static implicit operator Convertible(int ui) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $(ushort)33$; + } +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void UserDefinedImplicitConversion_PicksExactTargetTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static implicit operator int(Convertible i) {return 0; } + public static implicit operator short(Convertible s) {return 0; } +} +class Test { + public void M() { + int a = $new Convertible()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("i", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_PicksMostEncompassingTargetType() + { + string program = @"using System; +class Convertible { + public static implicit operator int(Convertible i) {return 0; } + public static implicit operator ushort(Convertible us) {return 0; } +} +class Test { + public void M() { + ulong a = $new Convertible()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("us", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_NoMostEncompassingTargetTypeIsInvalid() + { + string program = @"using System; +class Convertible { + public static implicit operator uint(Convertible i) {return 0; } + public static implicit operator short(Convertible us) {return 0; } +} +class Test { + public void M() { + long a = $new Convertible()$; + } +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void UserDefinedImplicitConversion_AmbiguousIsInvalid() + { + string program = @"using System; +class Convertible1 { + public static implicit operator Convertible2(Convertible1 c) {return 0; } +} +class Convertible2 { + public static implicit operator Convertible2(Convertible1 c) {return 0; } +} +class Test { + public void M() { + Convertible2 a = $new Convertible1()$; + } +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void UserDefinedImplicitConversion_DefinedNullableTakesPrecedenceOverLifted() + { + string program = @"using System; +struct Convertible { + public static implicit operator Convertible(int i) {return new Convertible(); } + public static implicit operator Convertible?(int? ni) {return new Convertible(); } +} +class Test { + public void M() { + Convertible? a = $(int?)33$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.IsFalse(c.IsLifted); + Assert.AreEqual("ni", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_UIntConstant() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(long l) {return new Convertible(); } + public static implicit operator Convertible(uint ui) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $33$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("ui", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_NullableUIntConstant() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(long? l) {return new Convertible(); } + public static implicit operator Convertible(uint? ui) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $33$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("ui", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_UseShortResult_BecauseNullableCannotBeUnpacked() + { + string program = @"using System; +class Test { + public static implicit operator int?(Test i) { return 0; } + public static implicit operator short(Test s) { return 0; } +} +class Program { + public static void Main(string[] args) + { + int x = $new Test()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("System.Int16", c.Method.ReturnType.FullName); + } + + [Test] + public void UserDefinedImplicitConversion_Short_Or_NullableByte_Target() + { + string program = @"using System; +class Test { + public static implicit operator short(Test s) { return 0; } + public static implicit operator byte?(Test b) { return 0; } +} +class Program { + public static void Main(string[] args) + { + int? x = $new Test()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("System.Int16", c.Method.ReturnType.FullName); + } + + [Test] + public void UserDefinedImplicitConversion_Byte_Or_NullableShort_Target() + { + string program = @"using System; +class Test { + public static implicit operator byte(Test b) { return 0; } + public static implicit operator short?(Test s) { return 0; } +} +class Program { + public static void Main(string[] args) + { + int? x = $new Test()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("s", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_Int_Or_NullableLong_Source() + { + string program = @"using System; +class Test { + public static implicit operator Test(int i) { return new Test(); } + public static implicit operator Test(long? l) { return new Test(); } +} +class Program { + static void Main() { + short s = 0; + Test t = $s$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("i", c.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedImplicitConversion_NullableInt_Or_Long_Source() + { + string program = @"using System; +class Test { + public static implicit operator Test(int? i) { return new Test(); } + public static implicit operator Test(long l) { return new Test(); } +} +class Program { + static void Main() { + short s = 0; + Test t = $s$; + } +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + } + + [Test] + public void UserDefinedImplicitConversion_NullableInt_Or_Long_Constant_Source() + { + string program = @"using System; +class Test { + public static implicit operator Test(int? i) { return new Test(); } + public static implicit operator Test(long l) { return new Test(); } +} +class Program { + static void Main() { + Test t = $1$; + } +}"; + var c = GetConversion(program); + Assert.IsFalse(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + } + + [Test] + public void UserDefinedImplicitConversion_NullableInt_Or_NullableLong_Source() + { + string program = @"using System; +class Test { + public static implicit operator Test(int? i) { return new Test(); } + public static implicit operator Test(long? l) { return new Test(); } +} +class Program { + static void Main() { + short s = 0; + Test t = $s$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsUserDefined); + Assert.AreEqual("i", c.Method.Parameters[0].Name); + } + + [Test] + public void PreferUserDefinedConversionOverReferenceConversion() + { + // actually this is not because user-defined conversions are better; + // but because string is a better conversion target + string program = @" +class AA { + public static implicit operator string(AA a) { return null; } +} +class Test { + static void M(object obj) {} + static void M(string str) {} + + static void Main() { + $M(new AA())$; + } +}"; + + var rr = Resolve(program); + Assert.IsFalse(rr.IsError); + Assert.AreEqual("str", rr.Member.Parameters[0].Name); + } + + [Test] + public void PreferAmbiguousConversionOverReferenceConversion() + { + // Ambiguous conversions are a compiler error; but they are not + // preventing the overload from being chosen. + + // The user-defined conversion wins because BB is a better conversion target than object. + string program = @" +class AA { + public static implicit operator BB(AA a) { return null; } +} +class BB { + public static implicit operator BB(AA a) { return null; } +} + +class Test { + static void M(BB b) {} + static void M(object o) {} + + static void Main() { + M($new AA()$); + } +}"; + + var c = GetConversion(program); + Assert.IsTrue(c.IsUserDefined); + Assert.IsFalse(c.IsValid); + } + + [Test] + public void UserDefinedImplicitConversion_ConversionBeforeUserDefinedOperatorIsCorrect() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(long l) {return new Convertible(); } +} +class Test { + public void M() { + int i = 33; + Convertible a = $i$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.ConversionBeforeUserDefinedOperator.IsImplicit); + Assert.IsTrue(c.ConversionBeforeUserDefinedOperator.IsNumericConversion); + Assert.IsTrue(c.ConversionBeforeUserDefinedOperator.IsValid); + Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsIdentityConversion); + } + + [Test] + public void UserDefinedImplicitConversion_ConversionAfterUserDefinedOperatorIsCorrect() + { + string program = @"using System; +class Convertible { + public static implicit operator int(Convertible i) {return 0; } +} +class Test { + public void M() { + long a = $new Convertible()$; + } +}"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.ConversionBeforeUserDefinedOperator.IsIdentityConversion); + Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsImplicit); + Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsNumericConversion); + Assert.IsTrue(c.ConversionAfterUserDefinedOperator.IsValid); + } + + [Test] + public void UserDefinedImplicitConversion_IsImplicit() + { + // Bug icsharpcode/NRefactory#183: conversions from constant expressions were incorrectly marked as explicit + string program = @"using System; + class Test { + void Hello(JsNumber3 x) { + Hello($7$); + } + } + public class JsNumber3 { + public static implicit operator JsNumber3(int d) { + return null; + } + }"; + var c = GetConversion(program); + Assert.IsTrue(c.IsValid); + Assert.IsTrue(c.IsImplicit); + Assert.IsFalse(c.IsExplicit); + Assert.AreEqual(Conversion.IdentityConversion, c.ConversionBeforeUserDefinedOperator); + Assert.AreEqual(Conversion.IdentityConversion, c.ConversionAfterUserDefinedOperator); + } + */ + } +} diff --git a/ICSharpCode.Decompiler.Tests/Semantics/ExplicitConversionTest.cs b/ICSharpCode.Decompiler.Tests/Semantics/ExplicitConversionTest.cs new file mode 100644 index 000000000..415ddcb05 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/Semantics/ExplicitConversionTest.cs @@ -0,0 +1,940 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using ICSharpCode.Decompiler.CSharp.Resolver; +using ICSharpCode.Decompiler.Semantics; +using ICSharpCode.Decompiler.Tests.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using NUnit.Framework; + +namespace ICSharpCode.Decompiler.Tests.Semantics +{ + using dynamic = ICSharpCode.Decompiler.TypeSystem.ReflectionHelper.Dynamic; + using C = Conversion; + + [TestFixture, Parallelizable(ParallelScope.All)] + public class ExplicitConversionsTest + { + CSharpConversions conversions; + ICompilation compilation; + + [OneTimeSetUp] + public void SetUp() + { + compilation = new SimpleCompilation(TypeSystemLoaderTests.TestAssembly, + TypeSystemLoaderTests.Mscorlib, + TypeSystemLoaderTests.SystemCore); + conversions = new CSharpConversions(compilation); + } + + Conversion ExplicitConversion(Type from, Type to) + { + IType from2 = compilation.FindType(from); + IType to2 = compilation.FindType(to); + return conversions.ExplicitConversion(from2, to2); + } + + [Test] + public void PointerConversion() + { + Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(int*), typeof(short))); + Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(short), typeof(void*))); + + Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(void*), typeof(int*))); + Assert.AreEqual(C.ExplicitPointerConversion, ExplicitConversion(typeof(long*), typeof(byte*))); + } + + [Test] + public void ConversionFromDynamic() + { + // Explicit dynamic conversion is for resolve results only; + // otherwise it's an explicit reference / unboxing conversion + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic), typeof(string))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(dynamic), typeof(int))); + + var dynamicRR = new ResolveResult(SpecialType.Dynamic); + Assert.AreEqual(C.ExplicitDynamicConversion, conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(string)))); + Assert.AreEqual(C.ExplicitDynamicConversion, conversions.ExplicitConversion(dynamicRR, compilation.FindType(typeof(int)))); + } + + [Test] + public void NumericConversions() + { + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(sbyte), typeof(uint))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(sbyte), typeof(char))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(char))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(sbyte))); + // if an implicit conversion exists, ExplicitConversion() should return that + Assert.AreEqual(C.ImplicitNumericConversion, ExplicitConversion(typeof(byte), typeof(int))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(double), typeof(float))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(double), typeof(decimal))); + Assert.AreEqual(C.ExplicitNumericConversion, ExplicitConversion(typeof(decimal), typeof(double))); + Assert.AreEqual(C.ImplicitNumericConversion, ExplicitConversion(typeof(int), typeof(decimal))); + + Assert.AreEqual(C.None, ExplicitConversion(typeof(bool), typeof(int))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(int), typeof(bool))); + } + + [Test] + public void EnumerationConversions() + { + var explicitEnumerationConversion = C.EnumerationConversion(false, false); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(sbyte), typeof(StringComparison))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(char), typeof(StringComparison))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(int), typeof(StringComparison))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(decimal), typeof(StringComparison))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(char))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(int))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(decimal))); + Assert.AreEqual(explicitEnumerationConversion, ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions))); + } + + [Test] + public void NullableConversion_BasedOnIdentityConversion() + { + Assert.AreEqual(C.IdentityConversion, ExplicitConversion(typeof(ArraySegment?), typeof(ArraySegment?))); + Assert.AreEqual(C.ImplicitNullableConversion, ExplicitConversion(typeof(ArraySegment), typeof(ArraySegment?))); + Assert.AreEqual(C.ExplicitNullableConversion, ExplicitConversion(typeof(ArraySegment?), typeof(ArraySegment))); + } + + [Test] + public void NullableConversion_BasedOnImplicitNumericConversion() + { + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(long?))); + Assert.AreEqual(C.ImplicitLiftedNumericConversion, ExplicitConversion(typeof(int), typeof(long?))); + Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(long))); + } + + [Test] + public void NullableConversion_BasedOnImplicitEnumerationConversion() + { + ResolveResult zero = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 0); + ResolveResult one = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 1); + Assert.AreEqual(C.EnumerationConversion(true, true), conversions.ExplicitConversion(zero, compilation.FindType(typeof(StringComparison?)))); + Assert.AreEqual(C.EnumerationConversion(false, true), conversions.ExplicitConversion(one, compilation.FindType(typeof(StringComparison?)))); + } + + [Test] + public void NullableConversion_BasedOnExplicitNumericConversion() + { + Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(short?))); + Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int), typeof(short?))); + Assert.AreEqual(C.ExplicitLiftedNumericConversion, ExplicitConversion(typeof(int?), typeof(short))); + } + + [Test] + public void NullableConversion_BasedOnExplicitEnumerationConversion() + { + C c = C.EnumerationConversion(false, true); // c = explicit lifted enumeration conversion + Assert.AreEqual(c, ExplicitConversion(typeof(int?), typeof(StringComparison?))); + Assert.AreEqual(c, ExplicitConversion(typeof(int), typeof(StringComparison?))); + Assert.AreEqual(c, ExplicitConversion(typeof(int?), typeof(StringComparison))); + + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(int?))); + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison), typeof(int?))); + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(int))); + + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions?))); + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison), typeof(StringSplitOptions?))); + Assert.AreEqual(c, ExplicitConversion(typeof(StringComparison?), typeof(StringSplitOptions))); + } + + [Test] + public void ExplicitReferenceConversion_SealedClass() + { + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object), typeof(string))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(string))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(string))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(string))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string), typeof(IEnumerable))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(string), typeof(IEnumerable))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(string), typeof(IEnumerable))); + } + + [Test] + public void ExplicitReferenceConversion_NonSealedClass() + { + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object), typeof(List))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(List))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(List))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(List))); + + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(List), typeof(IEnumerable))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(List), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(List), typeof(IEnumerable))); + + Assert.AreEqual(C.None, ExplicitConversion(typeof(List), typeof(List))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(List), typeof(List))); + } + + [Test] + public void ExplicitReferenceConversion_Interfaces() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(IConvertible))); + } + + [Test] + public void ExplicitReferenceConversion_Arrays() + { + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object[]), typeof(string[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic[]), typeof(string[]))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(object[,]))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(int[]))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(short[]), typeof(int[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Array), typeof(int[]))); + } + + [Test] + public void ExplicitReferenceConversion_InterfaceToArray() + { + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(ICloneable), typeof(int[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(string[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(string[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(object[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(dynamic[]))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(IEnumerable), typeof(int[]))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(object[,]))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(object[]))); + } + + [Test] + public void ExplicitReferenceConversion_ArrayToInterface() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(int[]), typeof(ICloneable))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string[]), typeof(IEnumerable))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(string[]), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(object[]), typeof(IEnumerable))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(dynamic[]), typeof(IEnumerable))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(int[]), typeof(IEnumerable))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(object[,]), typeof(IEnumerable))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(object[]), typeof(IEnumerable))); + } + + [Test] + public void ExplicitReferenceConversion_Delegates() + { + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(MulticastDelegate), typeof(Action))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Delegate), typeof(Action))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(ICloneable), typeof(Action))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(System.Threading.ThreadStart), typeof(Action))); + } + + [Test] + public void ExplicitReferenceConversion_GenericDelegates() + { + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(Action), typeof(Action))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action), typeof(Action))); + + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.ImplicitReferenceConversion, ExplicitConversion(typeof(Func), typeof(Func))); + + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action), typeof(Action))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Action), typeof(Action))); + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Action), typeof(Action>))); + + Assert.AreEqual(C.ExplicitReferenceConversion, ExplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Func), typeof(Func))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Func), typeof(Func>))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Func), typeof(Func>))); + } + + [Test] + public void UnboxingConversion() + { + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(int))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(decimal))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(ValueType), typeof(int))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(IFormattable), typeof(int))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(int))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(Enum), typeof(StringComparison))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Enum), typeof(int))); + } + + [Test] + public void LiftedUnboxingConversion() + { + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(int?))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(object), typeof(decimal?))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(ValueType), typeof(int?))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(IFormattable), typeof(int?))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(IEnumerable), typeof(int?))); + Assert.AreEqual(C.UnboxingConversion, ExplicitConversion(typeof(Enum), typeof(StringComparison?))); + Assert.AreEqual(C.None, ExplicitConversion(typeof(Enum), typeof(int?))); + } + + /* TODO: we should probably revive these tests somehow + Conversion ResolveCast(string program) + { + return Resolve(program).Conversion; + } + + [Test] + public void ObjectToTypeParameter() + { + string program = @"using System; +class Test { + public void M(object o) { + T t = $(T)o$; + } +}"; + Assert.AreEqual(C.UnboxingConversion, ResolveCast(program)); + } + + [Test] + public void UnrelatedClassToTypeParameter() + { + string program = @"using System; +class Test { + public void M(string o) { + T t = $(T)o$; + } +}"; + Assert.AreEqual(C.None, ResolveCast(program)); + } + + [Test] + public void IntefaceToTypeParameter() + { + string program = @"using System; +class Test { + public void M(IDisposable o) { + T t = $(T)o$; + } +}"; + Assert.AreEqual(C.UnboxingConversion, ResolveCast(program)); + } + + [Test] + public void TypeParameterToInterface() + { + string program = @"using System; +class Test { + public void M(T t) { + IDisposable d = $(IDisposable)t$; + } +}"; + Assert.AreEqual(C.BoxingConversion, ResolveCast(program)); + } + + [Test] + public void ValueTypeToTypeParameter() + { + string program = @"using System; +class Test { + public void M(ValueType o) where T : struct { + T t = $(T)o$; + } +}"; + Assert.AreEqual(C.UnboxingConversion, ResolveCast(program)); + } + + [Test] + public void InvalidTypeParameterConversion() + { + string program = @"using System; +class Test { + public void M(T t) { + U u = $(U)t$; + } +}"; + Assert.AreEqual(C.None, ResolveCast(program)); + } + + [Test] + public void TypeParameterConversion1() + { + string program = @"using System; +class Test { + public void M(T t) where T : U { + U u = $(U)t$; + } +}"; + Assert.AreEqual(C.BoxingConversion, ResolveCast(program)); + } + + [Test] + public void TypeParameterConversion1Array() + { + string program = @"using System; +class Test { + public void M(T[] t) where T : U { + U[] u = $(U[])t$; + } +}"; + Assert.AreEqual(C.None, ResolveCast(program)); + } + + [Test] + public void TypeParameterConversion2() + { + string program = @"using System; +class Test { + public void M(T t) where U : T { + U u = $(U)t$; + } +}"; + Assert.AreEqual(C.UnboxingConversion, ResolveCast(program)); + } + + [Test] + public void TypeParameterConversion2Array() + { + string program = @"using System; +class Test { + public void M(T[] t) where U : T { + U[] u = $(U[])t$; + } +}"; + Assert.AreEqual(C.None, ResolveCast(program)); + } + + [Test] + public void ImplicitTypeParameterConversionWithClassConstraint() + { + string program = @"using System; +class Test { + public void M(T t) where T : class where U : class, T { + U u = $(U)t$; + } +}"; + Assert.AreEqual(C.ExplicitReferenceConversion, ResolveCast(program)); + } + + [Test] + public void ImplicitTypeParameterArrayConversionWithClassConstraint() + { + string program = @"using System; +class Test { + public void M(T[] t) where T : class where U : class, T { + U[] u = $(U[])t$; + } +}"; + Assert.AreEqual(C.ExplicitReferenceConversion, ResolveCast(program)); + } + + [Test] + public void ImplicitTypeParameterConversionWithClassConstraintOnlyOnT() + { + string program = @"using System; +class Test { + public void M(T t) where U : class, T { + U u = $(U)t$; + } +}"; + Assert.AreEqual(C.ExplicitReferenceConversion, ResolveCast(program)); + } + + [Test] + public void ImplicitTypeParameterArrayConversionWithClassConstraintOnlyOnT() + { + string program = @"using System; +class Test { + public void M(T[] t) where U : class, T { + U[] u = $(U[])t$; + } +}"; + Assert.AreEqual(C.ExplicitReferenceConversion, ResolveCast(program)); + } + + [Test] + public void SimpleUserDefinedConversion() + { + var rr = Resolve(@" +class C1 {} +class C2 { + public static explicit operator C1(C2 c2) { + return null; + } +} +class C { + public void M() { + var c2 = new C2(); + C1 c1 = $(C1)c2$; + } +}"); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("op_Explicit", rr.Conversion.Method.Name); + } + + [Test] + public void ExplicitReferenceConversionFollowedByUserDefinedConversion() + { + var rr = Resolve(@" + class B {} + class S : B {} + class T { + public static explicit operator T(S s) { return null; } + } + class Test { + void Run(B b) { + T t = $(T)b$; + } + }"); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("B", rr.Input.Type.Name); + } + + [Test] + public void ImplicitUserDefinedConversionFollowedByExplicitNumericConversion() + { + var rr = Resolve(@" + struct T { + public static implicit operator float(T t) { return 0; } + } + class Test { + void Run(T t) { + int x = $(int)t$; + } + }"); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + // even though the user-defined conversion is implicit, the combined conversion is explicit + Assert.IsTrue(rr.Conversion.IsExplicit); + } + + [Test] + public void BothDirectConversionAndBaseClassConversionAvailable() + { + var rr = Resolve(@" + class B {} + class S : B {} + class T { + public static explicit operator T(S s) { return null; } + public static explicit operator T(B b) { return null; } + } + class Test { + void Run(B b) { + T t = $(T)b$; + } + }"); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("b", rr.Conversion.Method.Parameters.Single().Name); + } + + [Test] + public void UserDefinedExplicitConversion_PicksExactSourceTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } + public static explicit operator Convertible(short s) {return new Convertible(); } +} +class Test { + public void M() { + var a = $(Convertible)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_PicksMostEncompassedSourceTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(long l) {return new Convertible(); } + public static explicit operator Convertible(uint ui) {return new Convertible(); } +} +class Test { + public void M() { + var a = $(Convertible)(ushort)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_PicksMostEncompassingSourceType() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } + public static explicit operator Convertible(ushort us) {return new Convertible(); } +} +class Test { + public void M() { + var a = $(Convertible)(long)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_NoMostEncompassingSourceTypeIsInvalid() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(uint i) {return new Convertible(); } + public static explicit operator Convertible(short us) {return new Convertible(); } +} +class Test { + public void M() { + var a = $(Convertible)(long)33$; + } +}"; + var rr = Resolve(program); + Assert.IsFalse(rr.Conversion.IsValid); + } + + [Test] + public void UserDefinedExplicitConversion_PicksExactTargetTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static explicit operator int(Convertible i) {return 0; } + public static explicit operator short(Convertible s) {return 0; } +} +class Test { + public void M() { + var a = $(int)new Convertible()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_PicksMostEncompassingTargetTypeIfPossible() + { + string program = @"using System; +class Convertible { + public static explicit operator int(Convertible i) {return 0; } + public static explicit operator ushort(Convertible us) {return 0; } +} +class Test { + public void M() { + var a = $(ulong)new Convertible()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("us", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_PicksMostEncompassedTargetType() + { + string program = @"using System; +class Convertible { + public static explicit operator long(Convertible l) { return 0; } + public static explicit operator uint(Convertible ui) { return 0; } +} +class Test { + public void M() { + var a = $(ushort)new Convertible()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_NoMostEncompassedTargetTypeIsInvalid() + { + string program = @"using System; +class Convertible { + public static explicit operator ulong(Convertible l) { return 0; } + public static explicit operator int(Convertible ui) { return 0; } +} +class Test { + public void M() { + var a = $(ushort)new Convertible()$; + } +}"; + var rr = Resolve(program); + Assert.IsFalse(rr.Conversion.IsValid); + } + + [Test] + public void UserDefinedExplicitConversion_AmbiguousIsInvalid() + { + string program = @"using System; +class Convertible1 { + public static explicit operator Convertible2(Convertible1 c) {return 0; } +} +class Convertible2 { + public static explicit operator Convertible2(Convertible1 c) {return 0; } +} +class Test { + public void M() { + var a = $(Convertible2)new Convertible1()$; + } +}"; + var rr = Resolve(program); + Assert.IsFalse(rr.Conversion.IsValid); + } + + [Test] + public void UserDefinedExplicitConversion_Lifted() + { + string program = @"using System; +struct Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } +} +class Test { + public void M(int? i) { + a = $(Convertible?)i$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.IsTrue(rr.Conversion.IsLifted); + } + + [Test] + public void UserDefinedExplicitConversionFollowedByImplicitNullableConversion() + { + string program = @"using System; +struct Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } +} +class Test { + public void M(int i) { + a = $(Convertible?)i$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.IsFalse(rr.Conversion.IsLifted); + } + + [Test] + public void UserDefinedExplicitConversion_ExplicitNullable_ThenUserDefined() + { + string program = @"using System; +struct Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } + public static explicit operator Convertible?(int? ni) {return new Convertible(); } +} +class Test { + public void M(int? i) { + a = $(Convertible)i$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.IsFalse(rr.Conversion.IsLifted); + Assert.AreEqual("i", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_DefinedNullableTakesPrecedenceOverLifted() + { + string program = @"using System; +struct Convertible { + public static explicit operator Convertible(int i) {return new Convertible(); } + public static explicit operator Convertible?(int? ni) {return new Convertible(); } +} +class Test { + public void M() { + a = $(Convertible?)(int?)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.IsFalse(rr.Conversion.IsLifted); + Assert.AreEqual("ni", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_UIntConstant() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(long l) {return new Convertible(); } + public static explicit operator Convertible(uint ui) {return new Convertible(); } +} +class Test { + public void M() { + var a = $(Convertible)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_NullableUIntConstant() + { + string program = @"using System; +class Convertible { + public static explicit operator Convertible(long? l) {return new Convertible(); } + public static explicit operator Convertible(uint? ui) {return new Convertible(); } +} +class Test { + public void M() { + Convertible a = $(Convertible)33$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("ui", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UseDefinedExplicitConversion_Lifted() + { + string program = @" +struct Convertible { + public static explicit operator Convertible(int i) { return new Convertible(); } +} +class Test { + public void M(int? i) { + a = $(Convertible?)i$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.IsTrue(rr.Conversion.IsLifted); + Assert.IsTrue(rr.Input is LocalResolveResult); + } + + [Test] + public void UserDefinedExplicitConversion_Short_Or_NullableByte_Target() + { + string program = @"using System; +class Test { + public static explicit operator short(Test s) { return 0; } + public static explicit operator byte?(Test b) { return 0; } +} +class Program { + public static void Main(string[] args) + { + int? x = $(int?)new Test()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("System.Int16", rr.Conversion.Method.ReturnType.FullName); + } + + [Test] + public void UserDefinedExplicitConversion_Byte_Or_NullableShort_Target() + { + string program = @"using System; +class Test { + public static explicit operator byte(Test b) { return 0; } + public static explicit operator short?(Test s) { return 0; } +} +class Program { + public static void Main(string[] args) + { + int? x = $(int?)new Test()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("s", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void ExplicitConversionOperatorsCanOverrideApplicableImplicitOnes() + { + string program = @" +struct Convertible { + public static explicit operator int(Convertible ci) {return 0; } + public static implicit operator short(Convertible cs) {return 0; } +} +class Test { + static void Main() { + int i = $(int)new Convertible()$; // csc uses the explicit conversion operator + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.IsUserDefined); + Assert.AreEqual("ci", rr.Conversion.Method.Parameters[0].Name); + } + + [Test] + public void UserDefinedExplicitConversion_ConversionBeforeUserDefinedOperatorIsCorrect() + { + string program = @"using System; +class Convertible { + public static implicit operator Convertible(int l) {return new Convertible(); } +} +class Test { + public void M() { + long i = 33; + Convertible a = $(Convertible)i$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsValid); + Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsExplicit); + Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsNumericConversion); + Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsIdentityConversion); + } + + [Test] + public void UserDefinedExplicitConversion_ConversionAfterUserDefinedOperatorIsCorrect() + { + string program = @"using System; +class Convertible { + public static implicit operator long(Convertible i) {return 0; } +} +class Test { + public void M() { + int a = $(int)new Convertible()$; + } +}"; + var rr = Resolve(program); + Assert.IsTrue(rr.Conversion.IsValid); + Assert.IsTrue(rr.Conversion.ConversionBeforeUserDefinedOperator.IsIdentityConversion); + Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsValid); + Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsExplicit); + Assert.IsTrue(rr.Conversion.ConversionAfterUserDefinedOperator.IsNumericConversion); + }*/ + } +} diff --git a/ICSharpCode.Decompiler.Tests/Semantics/OverloadResolutionTests.cs b/ICSharpCode.Decompiler.Tests/Semantics/OverloadResolutionTests.cs index cb3823d65..d81acd915 100644 --- a/ICSharpCode.Decompiler.Tests/Semantics/OverloadResolutionTests.cs +++ b/ICSharpCode.Decompiler.Tests/Semantics/OverloadResolutionTests.cs @@ -1,11 +1,28 @@ -using System; +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; -using System.Text; -using System.Threading.Tasks; using ICSharpCode.Decompiler.CSharp.Resolver; using ICSharpCode.Decompiler.Semantics; +using ICSharpCode.Decompiler.Tests.TypeSystem; using ICSharpCode.Decompiler.TypeSystem; using ICSharpCode.Decompiler.TypeSystem.Implementation; using NUnit.Framework; @@ -17,13 +34,12 @@ namespace ICSharpCode.Decompiler.Tests.Semantics { ICompilation compilation; - [SetUp] + [OneTimeSetUp] public void SetUp() { - var cecilLoader = new CecilLoader() { IncludeInternalMembers = true }; - var mscorlib = cecilLoader.LoadAssemblyFile(typeof(object).Assembly.Location); - var systemCore = cecilLoader.LoadAssemblyFile(typeof(System.Linq.Enumerable).Assembly.Location); - compilation = new SimpleCompilation(cecilLoader.LoadAssemblyFile(typeof(OverloadResolutionTests).Assembly.Location), mscorlib, systemCore); + compilation = new SimpleCompilation(TypeSystemLoaderTests.TestAssembly, + TypeSystemLoaderTests.Mscorlib, + TypeSystemLoaderTests.SystemCore); } ResolveResult[] MakeArgumentList(params Type[] argumentTypes) diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/CompoundAssignment.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/CompoundAssignment.cs index 6ab6661a7..4c60b7afd 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/CompoundAssignment.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/CompoundAssignment.cs @@ -31,6 +31,7 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness UnsignedShiftRightInstanceField(); UnsignedShiftRightStaticProperty(); DivideByBigValue(); + Overflow(); } static void Test(int a, int b) @@ -77,9 +78,9 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness } } - static ushort shortField; + static short shortField; - public static ushort ShortProperty { + public static short ShortProperty { get { Console.WriteLine("In get_ShortProperty"); return shortField; @@ -90,6 +91,19 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness } } + static byte byteField; + + public static byte ByteProperty { + get { + Console.WriteLine("In get_ByteProperty"); + return byteField; + } + set { + Console.WriteLine("In set_ByteProperty, value={0}", value); + byteField = value; + } + } + public static Dictionary GetDict() { Console.WriteLine("In GetDict()"); @@ -144,15 +158,55 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness static void UnsignedShiftRightStaticProperty() { + Console.WriteLine("UnsignedShiftRightStaticProperty:"); StaticProperty = -15; Test(X(), StaticProperty = (int)((uint)StaticProperty >> 2)); + + ShortProperty = -20; + ShortProperty = (short)((uint)StaticProperty >> 2); + + ShortProperty = -30; + ShortProperty = (short)((ushort)StaticProperty >> 2); } - + static void DivideByBigValue() { - ShortProperty = 5; - // can't use "ShortProperty /= (ushort)(ushort.MaxValue + 3)" because that would be division by 2. - ShortProperty = (ushort)(ShortProperty / (ushort.MaxValue + 3)); + Console.WriteLine("DivideByBigValue:"); + ByteProperty = 5; + // can't use "ByteProperty /= (byte)(byte.MaxValue + 3)" because that would be division by 2. + ByteProperty = (byte)(ByteProperty / (byte.MaxValue + 3)); + + ByteProperty = 200; + ByteProperty = (byte)(ByteProperty / Id(byte.MaxValue + 3)); + + ShortProperty = short.MaxValue; + ShortProperty = (short)(ShortProperty / (short.MaxValue + 3)); + } + + static void Overflow() + { + Console.WriteLine("Overflow:"); + ByteProperty = 0; + ByteProperty = (byte)checked(ByteProperty + 300); + try { + ByteProperty = checked((byte)(ByteProperty + 300)); + } catch (OverflowException) { + Console.WriteLine("Overflow OK"); + } + + ByteProperty = 200; + ByteProperty = (byte)checked(ByteProperty + 100); + ByteProperty = 201; + try { + ByteProperty = checked((byte)(ByteProperty + 100)); + } catch (OverflowException) { + Console.WriteLine("Overflow OK"); + } + } + + static T Id(T val) + { + return val; } } } \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/MemberLookup.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/MemberLookup.cs index 4d29ebcac..d41b30775 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/MemberLookup.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/MemberLookup.cs @@ -29,6 +29,7 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness Console.WriteLine((new Child1() as Base1).Field); Child1.Test(); delegateConstruction(); + new Child2b().CallTestMethod(); return 0; } @@ -82,6 +83,8 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness child.TestMethod(); Console.WriteLine("Child1.TestMethod()"); Console.WriteLine("Property = " + Property + " " + base.Property); + Console.WriteLine("Field = " + Field); + Console.WriteLine("base.Field = " + base.Field); } new public void TestAction() @@ -97,5 +100,24 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness } } } + + class Child2 : Base1 + { + public void CallTestMethod() + { + Console.WriteLine("Child2 calling this.TestMethod():"); + this.TestMethod(); + Console.WriteLine("Child2 calling base.TestMethod():"); + base.TestMethod(); + } + } + + class Child2b : Child2 + { + protected override void TestMethod() + { + Console.WriteLine("Child2b.TestMethod"); + } + } } } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.cs new file mode 100644 index 000000000..d927e3fd0 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.cs @@ -0,0 +1,412 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Reflection; + +namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty +{ + public class Switch + { + public class SetProperty + { + public readonly PropertyInfo Property; + private int _set; + + public int Set { + get { + return _set; + } + + set { + _set = value; + } + } + + public SetProperty(PropertyInfo property) + { + Property = property; + } + } + + public enum State + { + False, + True, + Null + } + + public static string SparseIntegerSwitch(int i) + { + Console.WriteLine("SparseIntegerSwitch: " + i); + switch (i) { + case -10000000: + return "-10 mln"; + case -100: + return "-hundred"; + case -1: + return "-1"; + case 0: + return "0"; + case 1: + return "1"; + case 2: + return "2"; + case 4: + return "4"; + case 100: + return "hundred"; + case 10000: + return "ten thousand"; + case 10001: + return "ten thousand and one"; + case int.MaxValue: + return "int.MaxValue"; + default: + return "something else"; + } + } + + public static void SwitchOverInt(int i) + { + switch (i) { + case 0: + Console.WriteLine("zero"); + break; + case 5: + Console.WriteLine("five"); + break; + case 10: + Console.WriteLine("ten"); + break; + case 15: + Console.WriteLine("fifteen"); + break; + case 20: + Console.WriteLine("twenty"); + break; + case 25: + Console.WriteLine("twenty-five"); + break; + case 30: + Console.WriteLine("thirty"); + break; + } + } + + public static string ShortSwitchOverString(string text) + { + Console.WriteLine("ShortSwitchOverString: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + default: + return "Default"; + } + } + + public static string ShortSwitchOverStringWithNullCase(string text) + { + Console.WriteLine("ShortSwitchOverStringWithNullCase: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case null: + return "null"; + default: + return "Default"; + } + } + + public static string SwitchOverString1(string text) + { + Console.WriteLine("SwitchOverString1: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + case "2nd case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case null: + return null; + default: + return "Default"; + } + } + + public static string SwitchOverString2() + { + Console.WriteLine("SwitchOverString2:"); + switch (Environment.UserName) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case "Seventh case": + return "Text7"; + case "Eighth case": + return "Text8"; + case "Ninth case": + return "Text9"; + case "Tenth case": + return "Text10"; + case "Eleventh case": + return "Text11"; + default: + return "Default"; + } + } + + public static string TwoDifferentSwitchBlocksInTryFinally() + { + try { + Console.WriteLine("TwoDifferentSwitchBlocks:"); + switch (Environment.UserName) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case "Seventh case": + return "Text7"; + case "Eighth case": + return "Text8"; + case "Ninth case": + return "Text9"; + case "Tenth case": + return "Text10"; + case "Eleventh case": + return "Text11"; + default: + return "Default"; + } + } finally { + Console.WriteLine("Second switch:"); + switch (Console.ReadLine()) { + case "12": + Console.WriteLine("Te43234xt1"); + break; + case "13": + Console.WriteLine("Te223443xt2"); + break; + case "14": + Console.WriteLine("Te234xt3"); + break; + case "15": + Console.WriteLine("Tex243t4"); + break; + case "16": + Console.WriteLine("Tex243t5"); + break; + case "17": + Console.WriteLine("Text2346"); + break; + case "18": + Console.WriteLine("Text234234"); + break; + case "19 case": + Console.WriteLine("Text8234"); + break; + case "20 case": + Console.WriteLine("Text923423"); + break; + case "21 case": + Console.WriteLine("Text10"); + break; + case "22 case": + Console.WriteLine("Text1134123"); + break; + default: + Console.WriteLine("Defa234234ult"); + break; + } + } + } + + public static string SwitchOverBool(bool b) + { + Console.WriteLine("SwitchOverBool: " + b.ToString()); + switch (b) { + case true: + return bool.TrueString; + case false: + return bool.FalseString; + default: + return null; + } + } + + public static void SwitchInLoop(int i) + { + Console.WriteLine("SwitchInLoop: " + i); + while (true) { + switch (i) { + case 1: + Console.WriteLine("one"); + break; + case 2: + Console.WriteLine("two"); + break; + //case 3: + // Console.WriteLine("three"); + // continue; + case 4: + Console.WriteLine("four"); + return; + default: + Console.WriteLine("default"); + Console.WriteLine("more code"); + return; + } + i++; + } + } + + public static void SwitchWithGoto(int i) + { + Console.WriteLine("SwitchWithGoto: " + i); + switch (i) { + case 1: + Console.WriteLine("one"); + goto default; + case 2: + Console.WriteLine("two"); + goto case 3; + case 3: + Console.WriteLine("three"); + break; + case 4: + Console.WriteLine("four"); + return; + default: + Console.WriteLine("default"); + break; + } + Console.WriteLine("End of method"); + } + + private static SetProperty[] GetProperties() + { + return new SetProperty[0]; + } + + public static void SwitchOnStringInForLoop() + { + ArrayList arrayList = new ArrayList(); + ArrayList arrayList2 = new ArrayList(); + SetProperty[] properties = GetProperties(); + for (int i = 0; i < properties.Length; i++) { + Console.WriteLine("In for-loop"); + SetProperty setProperty = properties[i]; + switch (setProperty.Property.Name) { + case "Name1": + setProperty.Set = 1; + arrayList.Add(setProperty); + break; + case "Name2": + setProperty.Set = 2; + arrayList.Add(setProperty); + break; + case "Name3": + setProperty.Set = 3; + arrayList.Add(setProperty); + break; + case "Name4": + setProperty.Set = 4; + arrayList.Add(setProperty); + break; + case "Name5": + case "Name6": + arrayList.Add(setProperty); + break; + default: + arrayList2.Add(setProperty); + break; + } + } + } + + public static void SwitchWithComplexCondition(string[] args) + { + switch ((args.Length == 0) ? "dummy" : args[0]) { + case "a": + Console.WriteLine("a"); + break; + case "b": + Console.WriteLine("b"); + break; + case "c": + Console.WriteLine("c"); + break; + case "d": + Console.WriteLine("d"); + break; + } + Console.WriteLine("end"); + } + + public static void SwitchWithArray(string[] args) + { + switch (args[0]) { + case "a": + Console.WriteLine("a"); + break; + case "b": + Console.WriteLine("b"); + break; + case "c": + Console.WriteLine("c"); + break; + case "d": + Console.WriteLine("d"); + break; + } + Console.WriteLine("end"); + } + } +} \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.il new file mode 100644 index 000000000..86c960186 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Debug.il @@ -0,0 +1,1425 @@ + +// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 +// Copyright (c) Microsoft Corporation. All rights reserved. + + + +// Metadata version: v1.1.4322 +.assembly extern mscorlib +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 1:0:5000:0 +} +.assembly CS1xSwitch_Debug +{ + + // --- The following custom attribute is added automatically, do not uncomment ------- + // .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(bool, + // bool) = ( 01 00 00 01 00 00 ) + + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.module CS1xSwitch_Debug.dll +// MVID: {3797A9DC-06AE-42B7-994E-BDC70F8FF69B} +.imagebase 0x00400000 +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 // WINDOWS_CUI +.corflags 0x00000001 // ILONLY +// Image base: 0x07560000 + + +// =============== CLASS MEMBERS DECLARATION =================== + +.class public auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch + extends [mscorlib]System.Object +{ + .class auto ansi nested public beforefieldinit SetProperty + extends [mscorlib]System.Object + { + .field public initonly class [mscorlib]System.Reflection.PropertyInfo Property + .field private int32 _set + .method public hidebysig specialname + instance int32 get_Set() cil managed + { + // Code size 11 (0xb) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::_set + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method SetProperty::get_Set + + .method public hidebysig specialname + instance void set_Set(int32 'value') cil managed + { + // Code size 8 (0x8) + .maxstack 2 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::_set + IL_0007: ret + } // end of method SetProperty::set_Set + + .method public hidebysig specialname rtspecialname + instance void .ctor(class [mscorlib]System.Reflection.PropertyInfo 'property') cil managed + { + // Code size 14 (0xe) + .maxstack 2 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ldarg.0 + IL_0007: ldarg.1 + IL_0008: stfld class [mscorlib]System.Reflection.PropertyInfo ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::Property + IL_000d: ret + } // end of method SetProperty::.ctor + + .property instance int32 Set() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::get_Set() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + } // end of property SetProperty::Set + } // end of class SetProperty + + .class auto ansi sealed nested public State + extends [mscorlib]System.Enum + { + .field public specialname rtspecialname int32 value__ + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State False = int32(0x00000000) + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State True = int32(0x00000001) + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State Null = int32(0x00000002) + } // end of class State + + .method public hidebysig static string + SparseIntegerSwitch(int32 i) cil managed + { + // Code size 207 (0xcf) + .maxstack 2 + .locals init (string V_0, + int32 V_1) + IL_0000: ldstr "SparseIntegerSwitch: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: ldarg.0 + IL_0016: stloc.1 + IL_0017: ldloc.1 + IL_0018: ldc.i4.4 + IL_0019: bgt.s IL_004a + + IL_001b: ldloc.1 + IL_001c: ldc.i4 0xff676980 + IL_0021: beq.s IL_006d + + IL_0023: ldloc.1 + IL_0024: ldc.i4.s -100 + IL_0026: beq.s IL_0075 + + IL_0028: ldloc.1 + IL_0029: ldc.i4.m1 + IL_002a: sub + IL_002b: switch ( + IL_007d, + IL_0085, + IL_008d, + IL_0095, + IL_00c5, + IL_009d) + IL_0048: br.s IL_00c5 + + IL_004a: ldloc.1 + IL_004b: ldc.i4.s 100 + IL_004d: beq.s IL_00a5 + + IL_004f: ldloc.1 + IL_0050: ldc.i4 0x2710 + IL_0055: sub + IL_0056: switch ( + IL_00ad, + IL_00b5) + IL_0063: ldloc.1 + IL_0064: ldc.i4 0x7fffffff + IL_0069: beq.s IL_00bd + + IL_006b: br.s IL_00c5 + + IL_006d: ldstr "-10 mln" + IL_0072: stloc.0 + IL_0073: br.s IL_00cd + + IL_0075: ldstr "-hundred" + IL_007a: stloc.0 + IL_007b: br.s IL_00cd + + IL_007d: ldstr "-1" + IL_0082: stloc.0 + IL_0083: br.s IL_00cd + + IL_0085: ldstr "0" + IL_008a: stloc.0 + IL_008b: br.s IL_00cd + + IL_008d: ldstr "1" + IL_0092: stloc.0 + IL_0093: br.s IL_00cd + + IL_0095: ldstr "2" + IL_009a: stloc.0 + IL_009b: br.s IL_00cd + + IL_009d: ldstr "4" + IL_00a2: stloc.0 + IL_00a3: br.s IL_00cd + + IL_00a5: ldstr "hundred" + IL_00aa: stloc.0 + IL_00ab: br.s IL_00cd + + IL_00ad: ldstr "ten thousand" + IL_00b2: stloc.0 + IL_00b3: br.s IL_00cd + + IL_00b5: ldstr "ten thousand and one" + IL_00ba: stloc.0 + IL_00bb: br.s IL_00cd + + IL_00bd: ldstr "int.MaxValue" + IL_00c2: stloc.0 + IL_00c3: br.s IL_00cd + + IL_00c5: ldstr "something else" + IL_00ca: stloc.0 + IL_00cb: br.s IL_00cd + + IL_00cd: ldloc.0 + IL_00ce: ret + } // end of method Switch::SparseIntegerSwitch + + .method public hidebysig static void SwitchOverInt(int32 i) cil managed + { + // Code size 136 (0x88) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: ldc.i4.s 10 + IL_0005: bgt.s IL_0016 + + IL_0007: ldloc.0 + IL_0008: ldc.i4.0 + IL_0009: beq.s IL_0033 + + IL_000b: ldloc.0 + IL_000c: ldc.i4.5 + IL_000d: beq.s IL_003f + + IL_000f: ldloc.0 + IL_0010: ldc.i4.s 10 + IL_0012: beq.s IL_004b + + IL_0014: br.s IL_0087 + + IL_0016: ldloc.0 + IL_0017: ldc.i4.s 20 + IL_0019: bgt.s IL_0027 + + IL_001b: ldloc.0 + IL_001c: ldc.i4.s 15 + IL_001e: beq.s IL_0057 + + IL_0020: ldloc.0 + IL_0021: ldc.i4.s 20 + IL_0023: beq.s IL_0063 + + IL_0025: br.s IL_0087 + + IL_0027: ldloc.0 + IL_0028: ldc.i4.s 25 + IL_002a: beq.s IL_006f + + IL_002c: ldloc.0 + IL_002d: ldc.i4.s 30 + IL_002f: beq.s IL_007b + + IL_0031: br.s IL_0087 + + IL_0033: ldstr "zero" + IL_0038: call void [mscorlib]System.Console::WriteLine(string) + IL_003d: br.s IL_0087 + + IL_003f: ldstr "five" + IL_0044: call void [mscorlib]System.Console::WriteLine(string) + IL_0049: br.s IL_0087 + + IL_004b: ldstr "ten" + IL_0050: call void [mscorlib]System.Console::WriteLine(string) + IL_0055: br.s IL_0087 + + IL_0057: ldstr "fifteen" + IL_005c: call void [mscorlib]System.Console::WriteLine(string) + IL_0061: br.s IL_0087 + + IL_0063: ldstr "twenty" + IL_0068: call void [mscorlib]System.Console::WriteLine(string) + IL_006d: br.s IL_0087 + + IL_006f: ldstr "twenty-five" + IL_0074: call void [mscorlib]System.Console::WriteLine(string) + IL_0079: br.s IL_0087 + + IL_007b: ldstr "thirty" + IL_0080: call void [mscorlib]System.Console::WriteLine(string) + IL_0085: br.s IL_0087 + + IL_0087: ret + } // end of method Switch::SwitchOverInt + + .method public hidebysig static string + ShortSwitchOverString(string text) cil managed + { + // Code size 105 (0x69) + .maxstack 3 + .locals init (string V_0, + string V_1) + IL_0000: ldstr "ShortSwitchOverString: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: ldstr "Third case" + IL_001f: leave.s IL_0021 + + IL_0021: ldarg.0 + IL_0022: dup + IL_0023: stloc.1 + IL_0024: brfalse.s IL_005f + + IL_0026: ldloc.1 + IL_0027: call string [mscorlib]System.String::IsInterned(string) + IL_002c: stloc.1 + IL_002d: ldloc.1 + IL_002e: ldstr "First case" + IL_0033: beq.s IL_0047 + + IL_0035: ldloc.1 + IL_0036: ldstr "Second case" + IL_003b: beq.s IL_004f + + IL_003d: ldloc.1 + IL_003e: ldstr "Third case" + IL_0043: beq.s IL_0057 + + IL_0045: br.s IL_005f + + IL_0047: ldstr "Text1" + IL_004c: stloc.0 + IL_004d: br.s IL_0067 + + IL_004f: ldstr "Text2" + IL_0054: stloc.0 + IL_0055: br.s IL_0067 + + IL_0057: ldstr "Text3" + IL_005c: stloc.0 + IL_005d: br.s IL_0067 + + IL_005f: ldstr "Default" + IL_0064: stloc.0 + IL_0065: br.s IL_0067 + + IL_0067: ldloc.0 + IL_0068: ret + } // end of method Switch::ShortSwitchOverString + + .method public hidebysig static string + ShortSwitchOverStringWithNullCase(string text) cil managed + { + // Code size 92 (0x5c) + .maxstack 2 + .locals init (string V_0, + string V_1) + IL_0000: ldstr "ShortSwitchOverStringWithNullCase: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: leave.s IL_001c + + IL_001c: ldarg.0 + IL_001d: dup + IL_001e: stloc.1 + IL_001f: brfalse.s IL_004a + + IL_0021: ldloc.1 + IL_0022: call string [mscorlib]System.String::IsInterned(string) + IL_0027: stloc.1 + IL_0028: ldloc.1 + IL_0029: ldstr "First case" + IL_002e: beq.s IL_003a + + IL_0030: ldloc.1 + IL_0031: ldstr "Second case" + IL_0036: beq.s IL_0042 + + IL_0038: br.s IL_0052 + + IL_003a: ldstr "Text1" + IL_003f: stloc.0 + IL_0040: br.s IL_005a + + IL_0042: ldstr "Text2" + IL_0047: stloc.0 + IL_0048: br.s IL_005a + + IL_004a: ldstr "null" + IL_004f: stloc.0 + IL_0050: br.s IL_005a + + IL_0052: ldstr "Default" + IL_0057: stloc.0 + IL_0058: br.s IL_005a + + IL_005a: ldloc.0 + IL_005b: ret + } // end of method Switch::ShortSwitchOverStringWithNullCase + + .method public hidebysig static string + SwitchOverString1(string text) cil managed + { + // Code size 185 (0xb9) + .maxstack 7 + .locals init (string V_0, + string V_1) + IL_0000: ldstr "SwitchOverString1: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: ldstr "2nd case" + IL_001f: ldstr "Third case" + IL_0024: ldstr "Fourth case" + IL_0029: ldstr "Fifth case" + IL_002e: ldstr "Sixth case" + IL_0033: leave.s IL_0035 + + IL_0035: ldarg.0 + IL_0036: dup + IL_0037: stloc.1 + IL_0038: brfalse.s IL_00ab + + IL_003a: ldloc.1 + IL_003b: call string [mscorlib]System.String::IsInterned(string) + IL_0040: stloc.1 + IL_0041: ldloc.1 + IL_0042: ldstr "First case" + IL_0047: beq.s IL_007b + + IL_0049: ldloc.1 + IL_004a: ldstr "Second case" + IL_004f: beq.s IL_0083 + + IL_0051: ldloc.1 + IL_0052: ldstr "2nd case" + IL_0057: beq.s IL_0083 + + IL_0059: ldloc.1 + IL_005a: ldstr "Third case" + IL_005f: beq.s IL_008b + + IL_0061: ldloc.1 + IL_0062: ldstr "Fourth case" + IL_0067: beq.s IL_0093 + + IL_0069: ldloc.1 + IL_006a: ldstr "Fifth case" + IL_006f: beq.s IL_009b + + IL_0071: ldloc.1 + IL_0072: ldstr "Sixth case" + IL_0077: beq.s IL_00a3 + + IL_0079: br.s IL_00af + + IL_007b: ldstr "Text1" + IL_0080: stloc.0 + IL_0081: br.s IL_00b7 + + IL_0083: ldstr "Text2" + IL_0088: stloc.0 + IL_0089: br.s IL_00b7 + + IL_008b: ldstr "Text3" + IL_0090: stloc.0 + IL_0091: br.s IL_00b7 + + IL_0093: ldstr "Text4" + IL_0098: stloc.0 + IL_0099: br.s IL_00b7 + + IL_009b: ldstr "Text5" + IL_00a0: stloc.0 + IL_00a1: br.s IL_00b7 + + IL_00a3: ldstr "Text6" + IL_00a8: stloc.0 + IL_00a9: br.s IL_00b7 + + IL_00ab: ldnull + IL_00ac: stloc.0 + IL_00ad: br.s IL_00b7 + + IL_00af: ldstr "Default" + IL_00b4: stloc.0 + IL_00b5: br.s IL_00b7 + + IL_00b7: ldloc.0 + IL_00b8: ret + } // end of method Switch::SwitchOverString1 + + .method public hidebysig static string + SwitchOverString2() cil managed + { + // Code size 418 (0x1a2) + .maxstack 4 + .locals init (string V_0, + object V_1) + IL_0000: volatile. + IL_0002: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_0007: brtrue IL_00dc + + IL_000c: ldc.i4.s 24 + IL_000e: ldc.r4 0.5 + IL_0013: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_0018: dup + IL_0019: ldstr "First case" + IL_001e: ldc.i4.0 + IL_001f: box [mscorlib]System.Int32 + IL_0024: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0029: dup + IL_002a: ldstr "Second case" + IL_002f: ldc.i4.1 + IL_0030: box [mscorlib]System.Int32 + IL_0035: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_003a: dup + IL_003b: ldstr "Third case" + IL_0040: ldc.i4.2 + IL_0041: box [mscorlib]System.Int32 + IL_0046: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_004b: dup + IL_004c: ldstr "Fourth case" + IL_0051: ldc.i4.3 + IL_0052: box [mscorlib]System.Int32 + IL_0057: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_005c: dup + IL_005d: ldstr "Fifth case" + IL_0062: ldc.i4.4 + IL_0063: box [mscorlib]System.Int32 + IL_0068: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_006d: dup + IL_006e: ldstr "Sixth case" + IL_0073: ldc.i4.5 + IL_0074: box [mscorlib]System.Int32 + IL_0079: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_007e: dup + IL_007f: ldstr "Seventh case" + IL_0084: ldc.i4.6 + IL_0085: box [mscorlib]System.Int32 + IL_008a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_008f: dup + IL_0090: ldstr "Eighth case" + IL_0095: ldc.i4.7 + IL_0096: box [mscorlib]System.Int32 + IL_009b: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00a0: dup + IL_00a1: ldstr "Ninth case" + IL_00a6: ldc.i4.8 + IL_00a7: box [mscorlib]System.Int32 + IL_00ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00b1: dup + IL_00b2: ldstr "Tenth case" + IL_00b7: ldc.i4.s 9 + IL_00b9: box [mscorlib]System.Int32 + IL_00be: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00c3: dup + IL_00c4: ldstr "Eleventh case" + IL_00c9: ldc.i4.s 10 + IL_00cb: box [mscorlib]System.Int32 + IL_00d0: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00d5: volatile. + IL_00d7: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_00dc: ldstr "SwitchOverString2:" + IL_00e1: call void [mscorlib]System.Console::WriteLine(string) + IL_00e6: call string [mscorlib]System.Environment::get_UserName() + IL_00eb: dup + IL_00ec: stloc.1 + IL_00ed: brfalse IL_0198 + + IL_00f2: volatile. + IL_00f4: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_00f9: ldloc.1 + IL_00fa: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_00ff: dup + IL_0100: stloc.1 + IL_0101: brfalse IL_0198 + + IL_0106: ldloc.1 + IL_0107: unbox [mscorlib]System.Int32 + IL_010c: ldind.i4 + IL_010d: switch ( + IL_0140, + IL_0148, + IL_0150, + IL_0158, + IL_0160, + IL_0168, + IL_0170, + IL_0178, + IL_0180, + IL_0188, + IL_0190) + IL_013e: br.s IL_0198 + + IL_0140: ldstr "Text1" + IL_0145: stloc.0 + IL_0146: br.s IL_01a0 + + IL_0148: ldstr "Text2" + IL_014d: stloc.0 + IL_014e: br.s IL_01a0 + + IL_0150: ldstr "Text3" + IL_0155: stloc.0 + IL_0156: br.s IL_01a0 + + IL_0158: ldstr "Text4" + IL_015d: stloc.0 + IL_015e: br.s IL_01a0 + + IL_0160: ldstr "Text5" + IL_0165: stloc.0 + IL_0166: br.s IL_01a0 + + IL_0168: ldstr "Text6" + IL_016d: stloc.0 + IL_016e: br.s IL_01a0 + + IL_0170: ldstr "Text7" + IL_0175: stloc.0 + IL_0176: br.s IL_01a0 + + IL_0178: ldstr "Text8" + IL_017d: stloc.0 + IL_017e: br.s IL_01a0 + + IL_0180: ldstr "Text9" + IL_0185: stloc.0 + IL_0186: br.s IL_01a0 + + IL_0188: ldstr "Text10" + IL_018d: stloc.0 + IL_018e: br.s IL_01a0 + + IL_0190: ldstr "Text11" + IL_0195: stloc.0 + IL_0196: br.s IL_01a0 + + IL_0198: ldstr "Default" + IL_019d: stloc.0 + IL_019e: br.s IL_01a0 + + IL_01a0: ldloc.0 + IL_01a1: ret + } // end of method Switch::SwitchOverString2 + + .method public hidebysig static string + TwoDifferentSwitchBlocksInTryFinally() cil managed + { + // Code size 925 (0x39d) + .maxstack 4 + .locals init (string V_0, + object V_1) + IL_0000: volatile. + IL_0002: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_0007: brtrue IL_01b8 + + IL_000c: ldc.i4.s 24 + IL_000e: ldc.r4 0.5 + IL_0013: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_0018: dup + IL_0019: ldstr "12" + IL_001e: ldc.i4.0 + IL_001f: box [mscorlib]System.Int32 + IL_0024: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0029: dup + IL_002a: ldstr "13" + IL_002f: ldc.i4.1 + IL_0030: box [mscorlib]System.Int32 + IL_0035: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_003a: dup + IL_003b: ldstr "14" + IL_0040: ldc.i4.2 + IL_0041: box [mscorlib]System.Int32 + IL_0046: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_004b: dup + IL_004c: ldstr "15" + IL_0051: ldc.i4.3 + IL_0052: box [mscorlib]System.Int32 + IL_0057: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_005c: dup + IL_005d: ldstr "16" + IL_0062: ldc.i4.4 + IL_0063: box [mscorlib]System.Int32 + IL_0068: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_006d: dup + IL_006e: ldstr "17" + IL_0073: ldc.i4.5 + IL_0074: box [mscorlib]System.Int32 + IL_0079: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_007e: dup + IL_007f: ldstr "18" + IL_0084: ldc.i4.6 + IL_0085: box [mscorlib]System.Int32 + IL_008a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_008f: dup + IL_0090: ldstr "19 case" + IL_0095: ldc.i4.7 + IL_0096: box [mscorlib]System.Int32 + IL_009b: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00a0: dup + IL_00a1: ldstr "20 case" + IL_00a6: ldc.i4.8 + IL_00a7: box [mscorlib]System.Int32 + IL_00ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00b1: dup + IL_00b2: ldstr "21 case" + IL_00b7: ldc.i4.s 9 + IL_00b9: box [mscorlib]System.Int32 + IL_00be: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00c3: dup + IL_00c4: ldstr "22 case" + IL_00c9: ldc.i4.s 10 + IL_00cb: box [mscorlib]System.Int32 + IL_00d0: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00d5: volatile. + IL_00d7: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_00dc: volatile. + IL_00de: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + IL_00e3: brtrue IL_01b8 + + IL_00e8: ldc.i4.s 24 + IL_00ea: ldc.r4 0.5 + IL_00ef: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_00f4: dup + IL_00f5: ldstr "First case" + IL_00fa: ldc.i4.0 + IL_00fb: box [mscorlib]System.Int32 + IL_0100: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0105: dup + IL_0106: ldstr "Second case" + IL_010b: ldc.i4.1 + IL_010c: box [mscorlib]System.Int32 + IL_0111: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0116: dup + IL_0117: ldstr "Third case" + IL_011c: ldc.i4.2 + IL_011d: box [mscorlib]System.Int32 + IL_0122: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0127: dup + IL_0128: ldstr "Fourth case" + IL_012d: ldc.i4.3 + IL_012e: box [mscorlib]System.Int32 + IL_0133: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0138: dup + IL_0139: ldstr "Fifth case" + IL_013e: ldc.i4.4 + IL_013f: box [mscorlib]System.Int32 + IL_0144: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0149: dup + IL_014a: ldstr "Sixth case" + IL_014f: ldc.i4.5 + IL_0150: box [mscorlib]System.Int32 + IL_0155: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_015a: dup + IL_015b: ldstr "Seventh case" + IL_0160: ldc.i4.6 + IL_0161: box [mscorlib]System.Int32 + IL_0166: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_016b: dup + IL_016c: ldstr "Eighth case" + IL_0171: ldc.i4.7 + IL_0172: box [mscorlib]System.Int32 + IL_0177: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_017c: dup + IL_017d: ldstr "Ninth case" + IL_0182: ldc.i4.8 + IL_0183: box [mscorlib]System.Int32 + IL_0188: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_018d: dup + IL_018e: ldstr "Tenth case" + IL_0193: ldc.i4.s 9 + IL_0195: box [mscorlib]System.Int32 + IL_019a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_019f: dup + IL_01a0: ldstr "Eleventh case" + IL_01a5: ldc.i4.s 10 + IL_01a7: box [mscorlib]System.Int32 + IL_01ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_01b1: volatile. + IL_01b3: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + .try + { + IL_01b8: ldstr "TwoDifferentSwitchBlocks:" + IL_01bd: call void [mscorlib]System.Console::WriteLine(string) + IL_01c2: call string [mscorlib]System.Environment::get_UserName() + IL_01c7: dup + IL_01c8: stloc.1 + IL_01c9: brfalse IL_0295 + + IL_01ce: volatile. + IL_01d0: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + IL_01d5: ldloc.1 + IL_01d6: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_01db: dup + IL_01dc: stloc.1 + IL_01dd: brfalse IL_0295 + + IL_01e2: ldloc.1 + IL_01e3: unbox [mscorlib]System.Int32 + IL_01e8: ldind.i4 + IL_01e9: switch ( + IL_021c, + IL_0227, + IL_0232, + IL_023d, + IL_0248, + IL_0253, + IL_025e, + IL_0269, + IL_0274, + IL_027f, + IL_028a) + IL_021a: br.s IL_0295 + + IL_021c: ldstr "Text1" + IL_0221: stloc.0 + IL_0222: leave IL_039b + + IL_0227: ldstr "Text2" + IL_022c: stloc.0 + IL_022d: leave IL_039b + + IL_0232: ldstr "Text3" + IL_0237: stloc.0 + IL_0238: leave IL_039b + + IL_023d: ldstr "Text4" + IL_0242: stloc.0 + IL_0243: leave IL_039b + + IL_0248: ldstr "Text5" + IL_024d: stloc.0 + IL_024e: leave IL_039b + + IL_0253: ldstr "Text6" + IL_0258: stloc.0 + IL_0259: leave IL_039b + + IL_025e: ldstr "Text7" + IL_0263: stloc.0 + IL_0264: leave IL_039b + + IL_0269: ldstr "Text8" + IL_026e: stloc.0 + IL_026f: leave IL_039b + + IL_0274: ldstr "Text9" + IL_0279: stloc.0 + IL_027a: leave IL_039b + + IL_027f: ldstr "Text10" + IL_0284: stloc.0 + IL_0285: leave IL_039b + + IL_028a: ldstr "Text11" + IL_028f: stloc.0 + IL_0290: leave IL_039b + + IL_0295: ldstr "Default" + IL_029a: stloc.0 + IL_029b: leave IL_039b + + } // end .try + finally + { + IL_02a0: ldstr "Second switch:" + IL_02a5: call void [mscorlib]System.Console::WriteLine(string) + IL_02aa: call string [mscorlib]System.Console::ReadLine() + IL_02af: dup + IL_02b0: stloc.1 + IL_02b1: brfalse IL_038e + + IL_02b6: volatile. + IL_02b8: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_02bd: ldloc.1 + IL_02be: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_02c3: dup + IL_02c4: stloc.1 + IL_02c5: brfalse IL_038e + + IL_02ca: ldloc.1 + IL_02cb: unbox [mscorlib]System.Int32 + IL_02d0: ldind.i4 + IL_02d1: switch ( + IL_0307, + IL_0316, + IL_0322, + IL_032e, + IL_033a, + IL_0346, + IL_0352, + IL_035e, + IL_036a, + IL_0376, + IL_0382) + IL_0302: br IL_038e + + IL_0307: ldstr "Te43234xt1" + IL_030c: call void [mscorlib]System.Console::WriteLine(string) + IL_0311: br IL_039a + + IL_0316: ldstr "Te223443xt2" + IL_031b: call void [mscorlib]System.Console::WriteLine(string) + IL_0320: br.s IL_039a + + IL_0322: ldstr "Te234xt3" + IL_0327: call void [mscorlib]System.Console::WriteLine(string) + IL_032c: br.s IL_039a + + IL_032e: ldstr "Tex243t4" + IL_0333: call void [mscorlib]System.Console::WriteLine(string) + IL_0338: br.s IL_039a + + IL_033a: ldstr "Tex243t5" + IL_033f: call void [mscorlib]System.Console::WriteLine(string) + IL_0344: br.s IL_039a + + IL_0346: ldstr "Text2346" + IL_034b: call void [mscorlib]System.Console::WriteLine(string) + IL_0350: br.s IL_039a + + IL_0352: ldstr "Text234234" + IL_0357: call void [mscorlib]System.Console::WriteLine(string) + IL_035c: br.s IL_039a + + IL_035e: ldstr "Text8234" + IL_0363: call void [mscorlib]System.Console::WriteLine(string) + IL_0368: br.s IL_039a + + IL_036a: ldstr "Text923423" + IL_036f: call void [mscorlib]System.Console::WriteLine(string) + IL_0374: br.s IL_039a + + IL_0376: ldstr "Text10" + IL_037b: call void [mscorlib]System.Console::WriteLine(string) + IL_0380: br.s IL_039a + + IL_0382: ldstr "Text1134123" + IL_0387: call void [mscorlib]System.Console::WriteLine(string) + IL_038c: br.s IL_039a + + IL_038e: ldstr "Defa234234ult" + IL_0393: call void [mscorlib]System.Console::WriteLine(string) + IL_0398: br.s IL_039a + + IL_039a: endfinally + } // end handler + IL_039b: ldloc.0 + IL_039c: ret + } // end of method Switch::TwoDifferentSwitchBlocksInTryFinally + + .method public hidebysig static string + SwitchOverBool(bool b) cil managed + { + // Code size 62 (0x3e) + .maxstack 2 + .locals init (string V_0, + bool V_1) + IL_0000: ldstr "SwitchOverBool: " + IL_0005: ldarga.s b + IL_0007: call instance string [mscorlib]System.Boolean::ToString() + IL_000c: call string [mscorlib]System.String::Concat(string, + string) + IL_0011: call void [mscorlib]System.Console::WriteLine(string) + IL_0016: ldarg.0 + IL_0017: stloc.1 + IL_0018: ldloc.1 + IL_0019: switch ( + IL_0030, + IL_0028) + IL_0026: br.s IL_0038 + + IL_0028: ldsfld string [mscorlib]System.Boolean::TrueString + IL_002d: stloc.0 + IL_002e: br.s IL_003c + + IL_0030: ldsfld string [mscorlib]System.Boolean::FalseString + IL_0035: stloc.0 + IL_0036: br.s IL_003c + + IL_0038: ldnull + IL_0039: stloc.0 + IL_003a: br.s IL_003c + + IL_003c: ldloc.0 + IL_003d: ret + } // end of method Switch::SwitchOverBool + + .method public hidebysig static void SwitchInLoop(int32 i) cil managed + { + // Code size 117 (0x75) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldstr "SwitchInLoop: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: br.s IL_0072 + + IL_0017: ldarg.0 + IL_0018: stloc.0 + IL_0019: ldloc.0 + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: switch ( + IL_0033, + IL_003f, + IL_0057, + IL_004b) + IL_0031: br.s IL_0057 + + IL_0033: ldstr "one" + IL_0038: call void [mscorlib]System.Console::WriteLine(string) + IL_003d: br.s IL_006d + + IL_003f: ldstr "two" + IL_0044: call void [mscorlib]System.Console::WriteLine(string) + IL_0049: br.s IL_006d + + IL_004b: ldstr "four" + IL_0050: call void [mscorlib]System.Console::WriteLine(string) + IL_0055: br.s IL_0074 + + IL_0057: ldstr "default" + IL_005c: call void [mscorlib]System.Console::WriteLine(string) + IL_0061: ldstr "more code" + IL_0066: call void [mscorlib]System.Console::WriteLine(string) + IL_006b: br.s IL_0074 + + IL_006d: ldarg.0 + IL_006e: ldc.i4.1 + IL_006f: add + IL_0070: starg.s i + IL_0072: br.s IL_0017 + + IL_0074: ret + } // end of method Switch::SwitchInLoop + + .method public hidebysig static void SwitchWithGoto(int32 i) cil managed + { + // Code size 120 (0x78) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldstr "SwitchWithGoto: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: ldarg.0 + IL_0016: stloc.0 + IL_0017: ldloc.0 + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: switch ( + IL_0031, + IL_003d, + IL_0049, + IL_0055) + IL_002f: br.s IL_0061 + + IL_0031: ldstr "one" + IL_0036: call void [mscorlib]System.Console::WriteLine(string) + IL_003b: br.s IL_0061 + + IL_003d: ldstr "two" + IL_0042: call void [mscorlib]System.Console::WriteLine(string) + IL_0047: br.s IL_0049 + + IL_0049: ldstr "three" + IL_004e: call void [mscorlib]System.Console::WriteLine(string) + IL_0053: br.s IL_006d + + IL_0055: ldstr "four" + IL_005a: call void [mscorlib]System.Console::WriteLine(string) + IL_005f: br.s IL_0077 + + IL_0061: ldstr "default" + IL_0066: call void [mscorlib]System.Console::WriteLine(string) + IL_006b: br.s IL_006d + + IL_006d: ldstr "End of method" + IL_0072: call void [mscorlib]System.Console::WriteLine(string) + IL_0077: ret + } // end of method Switch::SwitchWithGoto + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] + GetProperties() cil managed + { + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] V_0) + IL_0000: ldc.i4.0 + IL_0001: newarr ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method Switch::GetProperties + + .method public hidebysig static void SwitchOnStringInForLoop() cil managed + { + // Code size 269 (0x10d) + .maxstack 6 + .locals init (class [mscorlib]System.Collections.ArrayList V_0, + class [mscorlib]System.Collections.ArrayList V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] V_2, + int32 V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty V_4, + string V_5) + IL_0000: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor() + IL_0005: stloc.0 + IL_0006: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor() + IL_000b: stloc.1 + IL_000c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch::GetProperties() + IL_0011: stloc.2 + IL_0012: ldc.i4.0 + IL_0013: stloc.3 + IL_0014: br IL_0103 + + IL_0019: ldstr "In for-loop" + IL_001e: call void [mscorlib]System.Console::WriteLine(string) + IL_0023: ldloc.2 + IL_0024: ldloc.3 + IL_0025: ldelem.ref + IL_0026: stloc.s V_4 + IL_0028: ldstr "Name1" + IL_002d: ldstr "Name2" + IL_0032: ldstr "Name3" + IL_0037: ldstr "Name4" + IL_003c: ldstr "Name5" + IL_0041: ldstr "Name6" + IL_0046: leave.s IL_0048 + + IL_0048: ldloc.s V_4 + IL_004a: ldfld class [mscorlib]System.Reflection.PropertyInfo ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::Property + IL_004f: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0054: dup + IL_0055: stloc.s V_5 + IL_0057: brfalse IL_00f4 + + IL_005c: ldloc.s V_5 + IL_005e: call string [mscorlib]System.String::IsInterned(string) + IL_0063: stloc.s V_5 + IL_0065: ldloc.s V_5 + IL_0067: ldstr "Name1" + IL_006c: beq.s IL_009d + + IL_006e: ldloc.s V_5 + IL_0070: ldstr "Name2" + IL_0075: beq.s IL_00b0 + + IL_0077: ldloc.s V_5 + IL_0079: ldstr "Name3" + IL_007e: beq.s IL_00c3 + + IL_0080: ldloc.s V_5 + IL_0082: ldstr "Name4" + IL_0087: beq.s IL_00d6 + + IL_0089: ldloc.s V_5 + IL_008b: ldstr "Name5" + IL_0090: beq.s IL_00e9 + + IL_0092: ldloc.s V_5 + IL_0094: ldstr "Name6" + IL_0099: beq.s IL_00e9 + + IL_009b: br.s IL_00f4 + + IL_009d: ldloc.s V_4 + IL_009f: ldc.i4.1 + IL_00a0: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00a5: ldloc.0 + IL_00a6: ldloc.s V_4 + IL_00a8: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00ad: pop + IL_00ae: br.s IL_00ff + + IL_00b0: ldloc.s V_4 + IL_00b2: ldc.i4.2 + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00b8: ldloc.0 + IL_00b9: ldloc.s V_4 + IL_00bb: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00c0: pop + IL_00c1: br.s IL_00ff + + IL_00c3: ldloc.s V_4 + IL_00c5: ldc.i4.3 + IL_00c6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00cb: ldloc.0 + IL_00cc: ldloc.s V_4 + IL_00ce: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00d3: pop + IL_00d4: br.s IL_00ff + + IL_00d6: ldloc.s V_4 + IL_00d8: ldc.i4.4 + IL_00d9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00de: ldloc.0 + IL_00df: ldloc.s V_4 + IL_00e1: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00e6: pop + IL_00e7: br.s IL_00ff + + IL_00e9: ldloc.0 + IL_00ea: ldloc.s V_4 + IL_00ec: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00f1: pop + IL_00f2: br.s IL_00ff + + IL_00f4: ldloc.1 + IL_00f5: ldloc.s V_4 + IL_00f7: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00fc: pop + IL_00fd: br.s IL_00ff + + IL_00ff: ldloc.3 + IL_0100: ldc.i4.1 + IL_0101: add + IL_0102: stloc.3 + IL_0103: ldloc.3 + IL_0104: ldloc.2 + IL_0105: ldlen + IL_0106: conv.i4 + IL_0107: blt IL_0019 + + IL_010c: ret + } // end of method Switch::SwitchOnStringInForLoop + + .method public hidebysig static void SwitchWithComplexCondition(string[] args) cil managed + { + // Code size 141 (0x8d) + .maxstack 4 + .locals init (string V_0) + IL_0000: ldstr "a" + IL_0005: ldstr "b" + IL_000a: ldstr "c" + IL_000f: ldstr "d" + IL_0014: leave.s IL_0016 + + IL_0016: ldarg.0 + IL_0017: ldlen + IL_0018: conv.i4 + IL_0019: brfalse.s IL_0020 + + IL_001b: ldarg.0 + IL_001c: ldc.i4.0 + IL_001d: ldelem.ref + IL_001e: br.s IL_0025 + + IL_0020: ldstr "dummy" + IL_0025: dup + IL_0026: stloc.0 + IL_0027: brfalse.s IL_0082 + + IL_0029: ldloc.0 + IL_002a: call string [mscorlib]System.String::IsInterned(string) + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldstr "a" + IL_0036: beq.s IL_0052 + + IL_0038: ldloc.0 + IL_0039: ldstr "b" + IL_003e: beq.s IL_005e + + IL_0040: ldloc.0 + IL_0041: ldstr "c" + IL_0046: beq.s IL_006a + + IL_0048: ldloc.0 + IL_0049: ldstr "d" + IL_004e: beq.s IL_0076 + + IL_0050: br.s IL_0082 + + IL_0052: ldstr "a" + IL_0057: call void [mscorlib]System.Console::WriteLine(string) + IL_005c: br.s IL_0082 + + IL_005e: ldstr "b" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: br.s IL_0082 + + IL_006a: ldstr "c" + IL_006f: call void [mscorlib]System.Console::WriteLine(string) + IL_0074: br.s IL_0082 + + IL_0076: ldstr "d" + IL_007b: call void [mscorlib]System.Console::WriteLine(string) + IL_0080: br.s IL_0082 + + IL_0082: ldstr "end" + IL_0087: call void [mscorlib]System.Console::WriteLine(string) + IL_008c: ret + } // end of method Switch::SwitchWithComplexCondition + + .method public hidebysig static void SwitchWithArray(string[] args) cil managed + { + // Code size 129 (0x81) + .maxstack 4 + .locals init (string V_0) + IL_0000: ldstr "a" + IL_0005: ldstr "b" + IL_000a: ldstr "c" + IL_000f: ldstr "d" + IL_0014: leave.s IL_0016 + + IL_0016: ldarg.0 + IL_0017: ldc.i4.0 + IL_0018: ldelem.ref + IL_0019: dup + IL_001a: stloc.0 + IL_001b: brfalse.s IL_0076 + + IL_001d: ldloc.0 + IL_001e: call string [mscorlib]System.String::IsInterned(string) + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: ldstr "a" + IL_002a: beq.s IL_0046 + + IL_002c: ldloc.0 + IL_002d: ldstr "b" + IL_0032: beq.s IL_0052 + + IL_0034: ldloc.0 + IL_0035: ldstr "c" + IL_003a: beq.s IL_005e + + IL_003c: ldloc.0 + IL_003d: ldstr "d" + IL_0042: beq.s IL_006a + + IL_0044: br.s IL_0076 + + IL_0046: ldstr "a" + IL_004b: call void [mscorlib]System.Console::WriteLine(string) + IL_0050: br.s IL_0076 + + IL_0052: ldstr "b" + IL_0057: call void [mscorlib]System.Console::WriteLine(string) + IL_005c: br.s IL_0076 + + IL_005e: ldstr "c" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: br.s IL_0076 + + IL_006a: ldstr "d" + IL_006f: call void [mscorlib]System.Console::WriteLine(string) + IL_0074: br.s IL_0076 + + IL_0076: ldstr "end" + IL_007b: call void [mscorlib]System.Console::WriteLine(string) + IL_0080: ret + } // end of method Switch::SwitchWithArray + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Switch::.ctor + +} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch + +.class private auto ansi '' + extends [mscorlib]System.Object +{ + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000006-1' + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000007-1' + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000007-2' +} // end of class '' + + +// ============================================================= + +// *********** DISASSEMBLY COMPLETE *********************** +// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\TestCases\ILPretty\CS1xSwitch_Debug.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.cs new file mode 100644 index 000000000..d927e3fd0 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.cs @@ -0,0 +1,412 @@ +// Copyright (c) AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Reflection; + +namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty +{ + public class Switch + { + public class SetProperty + { + public readonly PropertyInfo Property; + private int _set; + + public int Set { + get { + return _set; + } + + set { + _set = value; + } + } + + public SetProperty(PropertyInfo property) + { + Property = property; + } + } + + public enum State + { + False, + True, + Null + } + + public static string SparseIntegerSwitch(int i) + { + Console.WriteLine("SparseIntegerSwitch: " + i); + switch (i) { + case -10000000: + return "-10 mln"; + case -100: + return "-hundred"; + case -1: + return "-1"; + case 0: + return "0"; + case 1: + return "1"; + case 2: + return "2"; + case 4: + return "4"; + case 100: + return "hundred"; + case 10000: + return "ten thousand"; + case 10001: + return "ten thousand and one"; + case int.MaxValue: + return "int.MaxValue"; + default: + return "something else"; + } + } + + public static void SwitchOverInt(int i) + { + switch (i) { + case 0: + Console.WriteLine("zero"); + break; + case 5: + Console.WriteLine("five"); + break; + case 10: + Console.WriteLine("ten"); + break; + case 15: + Console.WriteLine("fifteen"); + break; + case 20: + Console.WriteLine("twenty"); + break; + case 25: + Console.WriteLine("twenty-five"); + break; + case 30: + Console.WriteLine("thirty"); + break; + } + } + + public static string ShortSwitchOverString(string text) + { + Console.WriteLine("ShortSwitchOverString: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + default: + return "Default"; + } + } + + public static string ShortSwitchOverStringWithNullCase(string text) + { + Console.WriteLine("ShortSwitchOverStringWithNullCase: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case null: + return "null"; + default: + return "Default"; + } + } + + public static string SwitchOverString1(string text) + { + Console.WriteLine("SwitchOverString1: " + text); + switch (text) { + case "First case": + return "Text1"; + case "Second case": + case "2nd case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case null: + return null; + default: + return "Default"; + } + } + + public static string SwitchOverString2() + { + Console.WriteLine("SwitchOverString2:"); + switch (Environment.UserName) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case "Seventh case": + return "Text7"; + case "Eighth case": + return "Text8"; + case "Ninth case": + return "Text9"; + case "Tenth case": + return "Text10"; + case "Eleventh case": + return "Text11"; + default: + return "Default"; + } + } + + public static string TwoDifferentSwitchBlocksInTryFinally() + { + try { + Console.WriteLine("TwoDifferentSwitchBlocks:"); + switch (Environment.UserName) { + case "First case": + return "Text1"; + case "Second case": + return "Text2"; + case "Third case": + return "Text3"; + case "Fourth case": + return "Text4"; + case "Fifth case": + return "Text5"; + case "Sixth case": + return "Text6"; + case "Seventh case": + return "Text7"; + case "Eighth case": + return "Text8"; + case "Ninth case": + return "Text9"; + case "Tenth case": + return "Text10"; + case "Eleventh case": + return "Text11"; + default: + return "Default"; + } + } finally { + Console.WriteLine("Second switch:"); + switch (Console.ReadLine()) { + case "12": + Console.WriteLine("Te43234xt1"); + break; + case "13": + Console.WriteLine("Te223443xt2"); + break; + case "14": + Console.WriteLine("Te234xt3"); + break; + case "15": + Console.WriteLine("Tex243t4"); + break; + case "16": + Console.WriteLine("Tex243t5"); + break; + case "17": + Console.WriteLine("Text2346"); + break; + case "18": + Console.WriteLine("Text234234"); + break; + case "19 case": + Console.WriteLine("Text8234"); + break; + case "20 case": + Console.WriteLine("Text923423"); + break; + case "21 case": + Console.WriteLine("Text10"); + break; + case "22 case": + Console.WriteLine("Text1134123"); + break; + default: + Console.WriteLine("Defa234234ult"); + break; + } + } + } + + public static string SwitchOverBool(bool b) + { + Console.WriteLine("SwitchOverBool: " + b.ToString()); + switch (b) { + case true: + return bool.TrueString; + case false: + return bool.FalseString; + default: + return null; + } + } + + public static void SwitchInLoop(int i) + { + Console.WriteLine("SwitchInLoop: " + i); + while (true) { + switch (i) { + case 1: + Console.WriteLine("one"); + break; + case 2: + Console.WriteLine("two"); + break; + //case 3: + // Console.WriteLine("three"); + // continue; + case 4: + Console.WriteLine("four"); + return; + default: + Console.WriteLine("default"); + Console.WriteLine("more code"); + return; + } + i++; + } + } + + public static void SwitchWithGoto(int i) + { + Console.WriteLine("SwitchWithGoto: " + i); + switch (i) { + case 1: + Console.WriteLine("one"); + goto default; + case 2: + Console.WriteLine("two"); + goto case 3; + case 3: + Console.WriteLine("three"); + break; + case 4: + Console.WriteLine("four"); + return; + default: + Console.WriteLine("default"); + break; + } + Console.WriteLine("End of method"); + } + + private static SetProperty[] GetProperties() + { + return new SetProperty[0]; + } + + public static void SwitchOnStringInForLoop() + { + ArrayList arrayList = new ArrayList(); + ArrayList arrayList2 = new ArrayList(); + SetProperty[] properties = GetProperties(); + for (int i = 0; i < properties.Length; i++) { + Console.WriteLine("In for-loop"); + SetProperty setProperty = properties[i]; + switch (setProperty.Property.Name) { + case "Name1": + setProperty.Set = 1; + arrayList.Add(setProperty); + break; + case "Name2": + setProperty.Set = 2; + arrayList.Add(setProperty); + break; + case "Name3": + setProperty.Set = 3; + arrayList.Add(setProperty); + break; + case "Name4": + setProperty.Set = 4; + arrayList.Add(setProperty); + break; + case "Name5": + case "Name6": + arrayList.Add(setProperty); + break; + default: + arrayList2.Add(setProperty); + break; + } + } + } + + public static void SwitchWithComplexCondition(string[] args) + { + switch ((args.Length == 0) ? "dummy" : args[0]) { + case "a": + Console.WriteLine("a"); + break; + case "b": + Console.WriteLine("b"); + break; + case "c": + Console.WriteLine("c"); + break; + case "d": + Console.WriteLine("d"); + break; + } + Console.WriteLine("end"); + } + + public static void SwitchWithArray(string[] args) + { + switch (args[0]) { + case "a": + Console.WriteLine("a"); + break; + case "b": + Console.WriteLine("b"); + break; + case "c": + Console.WriteLine("c"); + break; + case "d": + Console.WriteLine("d"); + break; + } + Console.WriteLine("end"); + } + } +} \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.il new file mode 100644 index 000000000..32bd71dee --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/CS1xSwitch_Release.il @@ -0,0 +1,1325 @@ + +// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 +// Copyright (c) Microsoft Corporation. All rights reserved. + + + +// Metadata version: v1.1.4322 +.assembly extern mscorlib +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 1:0:5000:0 +} +.assembly CS1xSwitch_Release +{ + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.module CS1xSwitch_Release.dll +// MVID: {E26201E5-5EC1-412E-BE6D-AE48AFAE6535} +.imagebase 0x00400000 +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 // WINDOWS_CUI +.corflags 0x00000001 // ILONLY +// Image base: 0x07560000 + + +// =============== CLASS MEMBERS DECLARATION =================== + +.class public auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch + extends [mscorlib]System.Object +{ + .class auto ansi nested public beforefieldinit SetProperty + extends [mscorlib]System.Object + { + .field public initonly class [mscorlib]System.Reflection.PropertyInfo Property + .field private int32 _set + .method public hidebysig specialname + instance int32 get_Set() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::_set + IL_0006: ret + } // end of method SetProperty::get_Set + + .method public hidebysig specialname + instance void set_Set(int32 'value') cil managed + { + // Code size 8 (0x8) + .maxstack 2 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::_set + IL_0007: ret + } // end of method SetProperty::set_Set + + .method public hidebysig specialname rtspecialname + instance void .ctor(class [mscorlib]System.Reflection.PropertyInfo 'property') cil managed + { + // Code size 14 (0xe) + .maxstack 2 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ldarg.0 + IL_0007: ldarg.1 + IL_0008: stfld class [mscorlib]System.Reflection.PropertyInfo ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::Property + IL_000d: ret + } // end of method SetProperty::.ctor + + .property instance int32 Set() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::get_Set() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + } // end of property SetProperty::Set + } // end of class SetProperty + + .class auto ansi sealed nested public State + extends [mscorlib]System.Enum + { + .field public specialname rtspecialname int32 value__ + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State False = int32(0x00000000) + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State True = int32(0x00000001) + .field public static literal valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/State Null = int32(0x00000002) + } // end of class State + + .method public hidebysig static string + SparseIntegerSwitch(int32 i) cil managed + { + // Code size 181 (0xb5) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldstr "SparseIntegerSwitch: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: ldarg.0 + IL_0016: stloc.0 + IL_0017: ldloc.0 + IL_0018: ldc.i4.4 + IL_0019: bgt.s IL_004a + + IL_001b: ldloc.0 + IL_001c: ldc.i4 0xff676980 + IL_0021: beq.s IL_006d + + IL_0023: ldloc.0 + IL_0024: ldc.i4.s -100 + IL_0026: beq.s IL_0073 + + IL_0028: ldloc.0 + IL_0029: ldc.i4.m1 + IL_002a: sub + IL_002b: switch ( + IL_0079, + IL_007f, + IL_0085, + IL_008b, + IL_00af, + IL_0091) + IL_0048: br.s IL_00af + + IL_004a: ldloc.0 + IL_004b: ldc.i4.s 100 + IL_004d: beq.s IL_0097 + + IL_004f: ldloc.0 + IL_0050: ldc.i4 0x2710 + IL_0055: sub + IL_0056: switch ( + IL_009d, + IL_00a3) + IL_0063: ldloc.0 + IL_0064: ldc.i4 0x7fffffff + IL_0069: beq.s IL_00a9 + + IL_006b: br.s IL_00af + + IL_006d: ldstr "-10 mln" + IL_0072: ret + + IL_0073: ldstr "-hundred" + IL_0078: ret + + IL_0079: ldstr "-1" + IL_007e: ret + + IL_007f: ldstr "0" + IL_0084: ret + + IL_0085: ldstr "1" + IL_008a: ret + + IL_008b: ldstr "2" + IL_0090: ret + + IL_0091: ldstr "4" + IL_0096: ret + + IL_0097: ldstr "hundred" + IL_009c: ret + + IL_009d: ldstr "ten thousand" + IL_00a2: ret + + IL_00a3: ldstr "ten thousand and one" + IL_00a8: ret + + IL_00a9: ldstr "int.MaxValue" + IL_00ae: ret + + IL_00af: ldstr "something else" + IL_00b4: ret + } // end of method Switch::SparseIntegerSwitch + + .method public hidebysig static void SwitchOverInt(int32 i) cil managed + { + // Code size 125 (0x7d) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: stloc.0 + IL_0002: ldloc.0 + IL_0003: ldc.i4.s 10 + IL_0005: bgt.s IL_0015 + + IL_0007: ldloc.0 + IL_0008: ldc.i4.0 + IL_0009: beq.s IL_0030 + + IL_000b: ldloc.0 + IL_000c: ldc.i4.5 + IL_000d: beq.s IL_003b + + IL_000f: ldloc.0 + IL_0010: ldc.i4.s 10 + IL_0012: beq.s IL_0046 + + IL_0014: ret + + IL_0015: ldloc.0 + IL_0016: ldc.i4.s 20 + IL_0018: bgt.s IL_0025 + + IL_001a: ldloc.0 + IL_001b: ldc.i4.s 15 + IL_001d: beq.s IL_0051 + + IL_001f: ldloc.0 + IL_0020: ldc.i4.s 20 + IL_0022: beq.s IL_005c + + IL_0024: ret + + IL_0025: ldloc.0 + IL_0026: ldc.i4.s 25 + IL_0028: beq.s IL_0067 + + IL_002a: ldloc.0 + IL_002b: ldc.i4.s 30 + IL_002d: beq.s IL_0072 + + IL_002f: ret + + IL_0030: ldstr "zero" + IL_0035: call void [mscorlib]System.Console::WriteLine(string) + IL_003a: ret + + IL_003b: ldstr "five" + IL_0040: call void [mscorlib]System.Console::WriteLine(string) + IL_0045: ret + + IL_0046: ldstr "ten" + IL_004b: call void [mscorlib]System.Console::WriteLine(string) + IL_0050: ret + + IL_0051: ldstr "fifteen" + IL_0056: call void [mscorlib]System.Console::WriteLine(string) + IL_005b: ret + + IL_005c: ldstr "twenty" + IL_0061: call void [mscorlib]System.Console::WriteLine(string) + IL_0066: ret + + IL_0067: ldstr "twenty-five" + IL_006c: call void [mscorlib]System.Console::WriteLine(string) + IL_0071: ret + + IL_0072: ldstr "thirty" + IL_0077: call void [mscorlib]System.Console::WriteLine(string) + IL_007c: ret + } // end of method Switch::SwitchOverInt + + .method public hidebysig static string + ShortSwitchOverString(string text) cil managed + { + // Code size 95 (0x5f) + .maxstack 3 + .locals init (string V_0) + IL_0000: ldstr "ShortSwitchOverString: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: ldstr "Third case" + IL_001f: leave.s IL_0021 + + IL_0021: ldarg.0 + IL_0022: dup + IL_0023: stloc.0 + IL_0024: brfalse.s IL_0059 + + IL_0026: ldloc.0 + IL_0027: call string [mscorlib]System.String::IsInterned(string) + IL_002c: stloc.0 + IL_002d: ldloc.0 + IL_002e: ldstr "First case" + IL_0033: beq.s IL_0047 + + IL_0035: ldloc.0 + IL_0036: ldstr "Second case" + IL_003b: beq.s IL_004d + + IL_003d: ldloc.0 + IL_003e: ldstr "Third case" + IL_0043: beq.s IL_0053 + + IL_0045: br.s IL_0059 + + IL_0047: ldstr "Text1" + IL_004c: ret + + IL_004d: ldstr "Text2" + IL_0052: ret + + IL_0053: ldstr "Text3" + IL_0058: ret + + IL_0059: ldstr "Default" + IL_005e: ret + } // end of method Switch::ShortSwitchOverString + + .method public hidebysig static string + ShortSwitchOverStringWithNullCase(string text) cil managed + { + // Code size 82 (0x52) + .maxstack 2 + .locals init (string V_0) + IL_0000: ldstr "ShortSwitchOverStringWithNullCase: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: leave.s IL_001c + + IL_001c: ldarg.0 + IL_001d: dup + IL_001e: stloc.0 + IL_001f: brfalse.s IL_0046 + + IL_0021: ldloc.0 + IL_0022: call string [mscorlib]System.String::IsInterned(string) + IL_0027: stloc.0 + IL_0028: ldloc.0 + IL_0029: ldstr "First case" + IL_002e: beq.s IL_003a + + IL_0030: ldloc.0 + IL_0031: ldstr "Second case" + IL_0036: beq.s IL_0040 + + IL_0038: br.s IL_004c + + IL_003a: ldstr "Text1" + IL_003f: ret + + IL_0040: ldstr "Text2" + IL_0045: ret + + IL_0046: ldstr "null" + IL_004b: ret + + IL_004c: ldstr "Default" + IL_0051: ret + } // end of method Switch::ShortSwitchOverStringWithNullCase + + .method public hidebysig static string + SwitchOverString1(string text) cil managed + { + // Code size 167 (0xa7) + .maxstack 7 + .locals init (string V_0) + IL_0000: ldstr "SwitchOverString1: " + IL_0005: ldarg.0 + IL_0006: call string [mscorlib]System.String::Concat(string, + string) + IL_000b: call void [mscorlib]System.Console::WriteLine(string) + IL_0010: ldstr "First case" + IL_0015: ldstr "Second case" + IL_001a: ldstr "2nd case" + IL_001f: ldstr "Third case" + IL_0024: ldstr "Fourth case" + IL_0029: ldstr "Fifth case" + IL_002e: ldstr "Sixth case" + IL_0033: leave.s IL_0035 + + IL_0035: ldarg.0 + IL_0036: dup + IL_0037: stloc.0 + IL_0038: brfalse.s IL_009f + + IL_003a: ldloc.0 + IL_003b: call string [mscorlib]System.String::IsInterned(string) + IL_0040: stloc.0 + IL_0041: ldloc.0 + IL_0042: ldstr "First case" + IL_0047: beq.s IL_007b + + IL_0049: ldloc.0 + IL_004a: ldstr "Second case" + IL_004f: beq.s IL_0081 + + IL_0051: ldloc.0 + IL_0052: ldstr "2nd case" + IL_0057: beq.s IL_0081 + + IL_0059: ldloc.0 + IL_005a: ldstr "Third case" + IL_005f: beq.s IL_0087 + + IL_0061: ldloc.0 + IL_0062: ldstr "Fourth case" + IL_0067: beq.s IL_008d + + IL_0069: ldloc.0 + IL_006a: ldstr "Fifth case" + IL_006f: beq.s IL_0093 + + IL_0071: ldloc.0 + IL_0072: ldstr "Sixth case" + IL_0077: beq.s IL_0099 + + IL_0079: br.s IL_00a1 + + IL_007b: ldstr "Text1" + IL_0080: ret + + IL_0081: ldstr "Text2" + IL_0086: ret + + IL_0087: ldstr "Text3" + IL_008c: ret + + IL_008d: ldstr "Text4" + IL_0092: ret + + IL_0093: ldstr "Text5" + IL_0098: ret + + IL_0099: ldstr "Text6" + IL_009e: ret + + IL_009f: ldnull + IL_00a0: ret + + IL_00a1: ldstr "Default" + IL_00a6: ret + } // end of method Switch::SwitchOverString1 + + .method public hidebysig static string + SwitchOverString2() cil managed + { + // Code size 389 (0x185) + .maxstack 4 + .locals init (object V_0) + IL_0000: volatile. + IL_0002: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_0007: brtrue IL_00dc + + IL_000c: ldc.i4.s 24 + IL_000e: ldc.r4 0.5 + IL_0013: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_0018: dup + IL_0019: ldstr "First case" + IL_001e: ldc.i4.0 + IL_001f: box [mscorlib]System.Int32 + IL_0024: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0029: dup + IL_002a: ldstr "Second case" + IL_002f: ldc.i4.1 + IL_0030: box [mscorlib]System.Int32 + IL_0035: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_003a: dup + IL_003b: ldstr "Third case" + IL_0040: ldc.i4.2 + IL_0041: box [mscorlib]System.Int32 + IL_0046: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_004b: dup + IL_004c: ldstr "Fourth case" + IL_0051: ldc.i4.3 + IL_0052: box [mscorlib]System.Int32 + IL_0057: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_005c: dup + IL_005d: ldstr "Fifth case" + IL_0062: ldc.i4.4 + IL_0063: box [mscorlib]System.Int32 + IL_0068: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_006d: dup + IL_006e: ldstr "Sixth case" + IL_0073: ldc.i4.5 + IL_0074: box [mscorlib]System.Int32 + IL_0079: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_007e: dup + IL_007f: ldstr "Seventh case" + IL_0084: ldc.i4.6 + IL_0085: box [mscorlib]System.Int32 + IL_008a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_008f: dup + IL_0090: ldstr "Eighth case" + IL_0095: ldc.i4.7 + IL_0096: box [mscorlib]System.Int32 + IL_009b: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00a0: dup + IL_00a1: ldstr "Ninth case" + IL_00a6: ldc.i4.8 + IL_00a7: box [mscorlib]System.Int32 + IL_00ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00b1: dup + IL_00b2: ldstr "Tenth case" + IL_00b7: ldc.i4.s 9 + IL_00b9: box [mscorlib]System.Int32 + IL_00be: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00c3: dup + IL_00c4: ldstr "Eleventh case" + IL_00c9: ldc.i4.s 10 + IL_00cb: box [mscorlib]System.Int32 + IL_00d0: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00d5: volatile. + IL_00d7: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_00dc: ldstr "SwitchOverString2:" + IL_00e1: call void [mscorlib]System.Console::WriteLine(string) + IL_00e6: call string [mscorlib]System.Environment::get_UserName() + IL_00eb: dup + IL_00ec: stloc.0 + IL_00ed: brfalse IL_017f + + IL_00f2: volatile. + IL_00f4: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000006-1' + IL_00f9: ldloc.0 + IL_00fa: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_00ff: dup + IL_0100: stloc.0 + IL_0101: brfalse.s IL_017f + + IL_0103: ldloc.0 + IL_0104: unbox [mscorlib]System.Int32 + IL_0109: ldind.i4 + IL_010a: switch ( + IL_013d, + IL_0143, + IL_0149, + IL_014f, + IL_0155, + IL_015b, + IL_0161, + IL_0167, + IL_016d, + IL_0173, + IL_0179) + IL_013b: br.s IL_017f + + IL_013d: ldstr "Text1" + IL_0142: ret + + IL_0143: ldstr "Text2" + IL_0148: ret + + IL_0149: ldstr "Text3" + IL_014e: ret + + IL_014f: ldstr "Text4" + IL_0154: ret + + IL_0155: ldstr "Text5" + IL_015a: ret + + IL_015b: ldstr "Text6" + IL_0160: ret + + IL_0161: ldstr "Text7" + IL_0166: ret + + IL_0167: ldstr "Text8" + IL_016c: ret + + IL_016d: ldstr "Text9" + IL_0172: ret + + IL_0173: ldstr "Text10" + IL_0178: ret + + IL_0179: ldstr "Text11" + IL_017e: ret + + IL_017f: ldstr "Default" + IL_0184: ret + } // end of method Switch::SwitchOverString2 + + .method public hidebysig static string + TwoDifferentSwitchBlocksInTryFinally() cil managed + { + // Code size 923 (0x39b) + .maxstack 4 + .locals init (string V_0, + object V_1) + IL_0000: volatile. + IL_0002: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_0007: brtrue IL_01b8 + + IL_000c: ldc.i4.s 24 + IL_000e: ldc.r4 0.5 + IL_0013: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_0018: dup + IL_0019: ldstr "12" + IL_001e: ldc.i4.0 + IL_001f: box [mscorlib]System.Int32 + IL_0024: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0029: dup + IL_002a: ldstr "13" + IL_002f: ldc.i4.1 + IL_0030: box [mscorlib]System.Int32 + IL_0035: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_003a: dup + IL_003b: ldstr "14" + IL_0040: ldc.i4.2 + IL_0041: box [mscorlib]System.Int32 + IL_0046: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_004b: dup + IL_004c: ldstr "15" + IL_0051: ldc.i4.3 + IL_0052: box [mscorlib]System.Int32 + IL_0057: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_005c: dup + IL_005d: ldstr "16" + IL_0062: ldc.i4.4 + IL_0063: box [mscorlib]System.Int32 + IL_0068: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_006d: dup + IL_006e: ldstr "17" + IL_0073: ldc.i4.5 + IL_0074: box [mscorlib]System.Int32 + IL_0079: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_007e: dup + IL_007f: ldstr "18" + IL_0084: ldc.i4.6 + IL_0085: box [mscorlib]System.Int32 + IL_008a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_008f: dup + IL_0090: ldstr "19 case" + IL_0095: ldc.i4.7 + IL_0096: box [mscorlib]System.Int32 + IL_009b: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00a0: dup + IL_00a1: ldstr "20 case" + IL_00a6: ldc.i4.8 + IL_00a7: box [mscorlib]System.Int32 + IL_00ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00b1: dup + IL_00b2: ldstr "21 case" + IL_00b7: ldc.i4.s 9 + IL_00b9: box [mscorlib]System.Int32 + IL_00be: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00c3: dup + IL_00c4: ldstr "22 case" + IL_00c9: ldc.i4.s 10 + IL_00cb: box [mscorlib]System.Int32 + IL_00d0: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_00d5: volatile. + IL_00d7: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_00dc: volatile. + IL_00de: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + IL_00e3: brtrue IL_01b8 + + IL_00e8: ldc.i4.s 24 + IL_00ea: ldc.r4 0.5 + IL_00ef: newobj instance void [mscorlib]System.Collections.Hashtable::.ctor(int32, + float32) + IL_00f4: dup + IL_00f5: ldstr "First case" + IL_00fa: ldc.i4.0 + IL_00fb: box [mscorlib]System.Int32 + IL_0100: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0105: dup + IL_0106: ldstr "Second case" + IL_010b: ldc.i4.1 + IL_010c: box [mscorlib]System.Int32 + IL_0111: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0116: dup + IL_0117: ldstr "Third case" + IL_011c: ldc.i4.2 + IL_011d: box [mscorlib]System.Int32 + IL_0122: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0127: dup + IL_0128: ldstr "Fourth case" + IL_012d: ldc.i4.3 + IL_012e: box [mscorlib]System.Int32 + IL_0133: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0138: dup + IL_0139: ldstr "Fifth case" + IL_013e: ldc.i4.4 + IL_013f: box [mscorlib]System.Int32 + IL_0144: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_0149: dup + IL_014a: ldstr "Sixth case" + IL_014f: ldc.i4.5 + IL_0150: box [mscorlib]System.Int32 + IL_0155: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_015a: dup + IL_015b: ldstr "Seventh case" + IL_0160: ldc.i4.6 + IL_0161: box [mscorlib]System.Int32 + IL_0166: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_016b: dup + IL_016c: ldstr "Eighth case" + IL_0171: ldc.i4.7 + IL_0172: box [mscorlib]System.Int32 + IL_0177: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_017c: dup + IL_017d: ldstr "Ninth case" + IL_0182: ldc.i4.8 + IL_0183: box [mscorlib]System.Int32 + IL_0188: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_018d: dup + IL_018e: ldstr "Tenth case" + IL_0193: ldc.i4.s 9 + IL_0195: box [mscorlib]System.Int32 + IL_019a: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_019f: dup + IL_01a0: ldstr "Eleventh case" + IL_01a5: ldc.i4.s 10 + IL_01a7: box [mscorlib]System.Int32 + IL_01ac: call instance void [mscorlib]System.Collections.Hashtable::Add(object, + object) + IL_01b1: volatile. + IL_01b3: stsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + .try + { + IL_01b8: ldstr "TwoDifferentSwitchBlocks:" + IL_01bd: call void [mscorlib]System.Console::WriteLine(string) + IL_01c2: call string [mscorlib]System.Environment::get_UserName() + IL_01c7: dup + IL_01c8: stloc.1 + IL_01c9: brfalse IL_0295 + + IL_01ce: volatile. + IL_01d0: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-2' + IL_01d5: ldloc.1 + IL_01d6: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_01db: dup + IL_01dc: stloc.1 + IL_01dd: brfalse IL_0295 + + IL_01e2: ldloc.1 + IL_01e3: unbox [mscorlib]System.Int32 + IL_01e8: ldind.i4 + IL_01e9: switch ( + IL_021c, + IL_0227, + IL_0232, + IL_023d, + IL_0248, + IL_0253, + IL_025e, + IL_0269, + IL_0274, + IL_027f, + IL_028a) + IL_021a: br.s IL_0295 + + IL_021c: ldstr "Text1" + IL_0221: stloc.0 + IL_0222: leave IL_0399 + + IL_0227: ldstr "Text2" + IL_022c: stloc.0 + IL_022d: leave IL_0399 + + IL_0232: ldstr "Text3" + IL_0237: stloc.0 + IL_0238: leave IL_0399 + + IL_023d: ldstr "Text4" + IL_0242: stloc.0 + IL_0243: leave IL_0399 + + IL_0248: ldstr "Text5" + IL_024d: stloc.0 + IL_024e: leave IL_0399 + + IL_0253: ldstr "Text6" + IL_0258: stloc.0 + IL_0259: leave IL_0399 + + IL_025e: ldstr "Text7" + IL_0263: stloc.0 + IL_0264: leave IL_0399 + + IL_0269: ldstr "Text8" + IL_026e: stloc.0 + IL_026f: leave IL_0399 + + IL_0274: ldstr "Text9" + IL_0279: stloc.0 + IL_027a: leave IL_0399 + + IL_027f: ldstr "Text10" + IL_0284: stloc.0 + IL_0285: leave IL_0399 + + IL_028a: ldstr "Text11" + IL_028f: stloc.0 + IL_0290: leave IL_0399 + + IL_0295: ldstr "Default" + IL_029a: stloc.0 + IL_029b: leave IL_0399 + + } // end .try + finally + { + IL_02a0: ldstr "Second switch:" + IL_02a5: call void [mscorlib]System.Console::WriteLine(string) + IL_02aa: call string [mscorlib]System.Console::ReadLine() + IL_02af: dup + IL_02b0: stloc.1 + IL_02b1: brfalse IL_038e + + IL_02b6: volatile. + IL_02b8: ldsfld class [mscorlib]System.Collections.Hashtable ''::'$$method0x6000007-1' + IL_02bd: ldloc.1 + IL_02be: call instance object [mscorlib]System.Collections.Hashtable::get_Item(object) + IL_02c3: dup + IL_02c4: stloc.1 + IL_02c5: brfalse IL_038e + + IL_02ca: ldloc.1 + IL_02cb: unbox [mscorlib]System.Int32 + IL_02d0: ldind.i4 + IL_02d1: switch ( + IL_0307, + IL_0316, + IL_0322, + IL_032e, + IL_033a, + IL_0346, + IL_0352, + IL_035e, + IL_036a, + IL_0376, + IL_0382) + IL_0302: br IL_038e + + IL_0307: ldstr "Te43234xt1" + IL_030c: call void [mscorlib]System.Console::WriteLine(string) + IL_0311: br IL_0398 + + IL_0316: ldstr "Te223443xt2" + IL_031b: call void [mscorlib]System.Console::WriteLine(string) + IL_0320: br.s IL_0398 + + IL_0322: ldstr "Te234xt3" + IL_0327: call void [mscorlib]System.Console::WriteLine(string) + IL_032c: br.s IL_0398 + + IL_032e: ldstr "Tex243t4" + IL_0333: call void [mscorlib]System.Console::WriteLine(string) + IL_0338: br.s IL_0398 + + IL_033a: ldstr "Tex243t5" + IL_033f: call void [mscorlib]System.Console::WriteLine(string) + IL_0344: br.s IL_0398 + + IL_0346: ldstr "Text2346" + IL_034b: call void [mscorlib]System.Console::WriteLine(string) + IL_0350: br.s IL_0398 + + IL_0352: ldstr "Text234234" + IL_0357: call void [mscorlib]System.Console::WriteLine(string) + IL_035c: br.s IL_0398 + + IL_035e: ldstr "Text8234" + IL_0363: call void [mscorlib]System.Console::WriteLine(string) + IL_0368: br.s IL_0398 + + IL_036a: ldstr "Text923423" + IL_036f: call void [mscorlib]System.Console::WriteLine(string) + IL_0374: br.s IL_0398 + + IL_0376: ldstr "Text10" + IL_037b: call void [mscorlib]System.Console::WriteLine(string) + IL_0380: br.s IL_0398 + + IL_0382: ldstr "Text1134123" + IL_0387: call void [mscorlib]System.Console::WriteLine(string) + IL_038c: br.s IL_0398 + + IL_038e: ldstr "Defa234234ult" + IL_0393: call void [mscorlib]System.Console::WriteLine(string) + IL_0398: endfinally + } // end handler + IL_0399: ldloc.0 + IL_039a: ret + } // end of method Switch::TwoDifferentSwitchBlocksInTryFinally + + .method public hidebysig static string + SwitchOverBool(bool b) cil managed + { + // Code size 54 (0x36) + .maxstack 2 + .locals init (bool V_0) + IL_0000: ldstr "SwitchOverBool: " + IL_0005: ldarga.s b + IL_0007: call instance string [mscorlib]System.Boolean::ToString() + IL_000c: call string [mscorlib]System.String::Concat(string, + string) + IL_0011: call void [mscorlib]System.Console::WriteLine(string) + IL_0016: ldarg.0 + IL_0017: stloc.0 + IL_0018: ldloc.0 + IL_0019: switch ( + IL_002e, + IL_0028) + IL_0026: br.s IL_0034 + + IL_0028: ldsfld string [mscorlib]System.Boolean::TrueString + IL_002d: ret + + IL_002e: ldsfld string [mscorlib]System.Boolean::FalseString + IL_0033: ret + + IL_0034: ldnull + IL_0035: ret + } // end of method Switch::SwitchOverBool + + .method public hidebysig static void SwitchInLoop(int32 i) cil managed + { + // Code size 112 (0x70) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldstr "SwitchInLoop: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: ldarg.0 + IL_0016: stloc.0 + IL_0017: ldloc.0 + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: switch ( + IL_0031, + IL_003d, + IL_0054, + IL_0049) + IL_002f: br.s IL_0054 + + IL_0031: ldstr "one" + IL_0036: call void [mscorlib]System.Console::WriteLine(string) + IL_003b: br.s IL_0069 + + IL_003d: ldstr "two" + IL_0042: call void [mscorlib]System.Console::WriteLine(string) + IL_0047: br.s IL_0069 + + IL_0049: ldstr "four" + IL_004e: call void [mscorlib]System.Console::WriteLine(string) + IL_0053: ret + + IL_0054: ldstr "default" + IL_0059: call void [mscorlib]System.Console::WriteLine(string) + IL_005e: ldstr "more code" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: ret + + IL_0069: ldarg.0 + IL_006a: ldc.i4.1 + IL_006b: add + IL_006c: starg.s i + IL_006e: br.s IL_0015 + } // end of method Switch::SwitchInLoop + + .method public hidebysig static void SwitchWithGoto(int32 i) cil managed + { + // Code size 115 (0x73) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: ldstr "SwitchWithGoto: " + IL_0005: ldarg.0 + IL_0006: box [mscorlib]System.Int32 + IL_000b: call string [mscorlib]System.String::Concat(object, + object) + IL_0010: call void [mscorlib]System.Console::WriteLine(string) + IL_0015: ldarg.0 + IL_0016: stloc.0 + IL_0017: ldloc.0 + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: switch ( + IL_0031, + IL_003d, + IL_0047, + IL_0053) + IL_002f: br.s IL_005e + + IL_0031: ldstr "one" + IL_0036: call void [mscorlib]System.Console::WriteLine(string) + IL_003b: br.s IL_005e + + IL_003d: ldstr "two" + IL_0042: call void [mscorlib]System.Console::WriteLine(string) + IL_0047: ldstr "three" + IL_004c: call void [mscorlib]System.Console::WriteLine(string) + IL_0051: br.s IL_0068 + + IL_0053: ldstr "four" + IL_0058: call void [mscorlib]System.Console::WriteLine(string) + IL_005d: ret + + IL_005e: ldstr "default" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: ldstr "End of method" + IL_006d: call void [mscorlib]System.Console::WriteLine(string) + IL_0072: ret + } // end of method Switch::SwitchWithGoto + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] + GetProperties() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + IL_0000: ldc.i4.0 + IL_0001: newarr ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty + IL_0006: ret + } // end of method Switch::GetProperties + + .method public hidebysig static void SwitchOnStringInForLoop() cil managed + { + // Code size 267 (0x10b) + .maxstack 6 + .locals init (class [mscorlib]System.Collections.ArrayList V_0, + class [mscorlib]System.Collections.ArrayList V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] V_2, + int32 V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty V_4, + string V_5) + IL_0000: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor() + IL_0005: stloc.0 + IL_0006: newobj instance void [mscorlib]System.Collections.ArrayList::.ctor() + IL_000b: stloc.1 + IL_000c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch::GetProperties() + IL_0011: stloc.2 + IL_0012: ldc.i4.0 + IL_0013: stloc.3 + IL_0014: br IL_0101 + + IL_0019: ldstr "In for-loop" + IL_001e: call void [mscorlib]System.Console::WriteLine(string) + IL_0023: ldloc.2 + IL_0024: ldloc.3 + IL_0025: ldelem.ref + IL_0026: stloc.s V_4 + IL_0028: ldstr "Name1" + IL_002d: ldstr "Name2" + IL_0032: ldstr "Name3" + IL_0037: ldstr "Name4" + IL_003c: ldstr "Name5" + IL_0041: ldstr "Name6" + IL_0046: leave.s IL_0048 + + IL_0048: ldloc.s V_4 + IL_004a: ldfld class [mscorlib]System.Reflection.PropertyInfo ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::Property + IL_004f: callvirt instance string [mscorlib]System.Reflection.MemberInfo::get_Name() + IL_0054: dup + IL_0055: stloc.s V_5 + IL_0057: brfalse IL_00f4 + + IL_005c: ldloc.s V_5 + IL_005e: call string [mscorlib]System.String::IsInterned(string) + IL_0063: stloc.s V_5 + IL_0065: ldloc.s V_5 + IL_0067: ldstr "Name1" + IL_006c: beq.s IL_009d + + IL_006e: ldloc.s V_5 + IL_0070: ldstr "Name2" + IL_0075: beq.s IL_00b0 + + IL_0077: ldloc.s V_5 + IL_0079: ldstr "Name3" + IL_007e: beq.s IL_00c3 + + IL_0080: ldloc.s V_5 + IL_0082: ldstr "Name4" + IL_0087: beq.s IL_00d6 + + IL_0089: ldloc.s V_5 + IL_008b: ldstr "Name5" + IL_0090: beq.s IL_00e9 + + IL_0092: ldloc.s V_5 + IL_0094: ldstr "Name6" + IL_0099: beq.s IL_00e9 + + IL_009b: br.s IL_00f4 + + IL_009d: ldloc.s V_4 + IL_009f: ldc.i4.1 + IL_00a0: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00a5: ldloc.0 + IL_00a6: ldloc.s V_4 + IL_00a8: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00ad: pop + IL_00ae: br.s IL_00fd + + IL_00b0: ldloc.s V_4 + IL_00b2: ldc.i4.2 + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00b8: ldloc.0 + IL_00b9: ldloc.s V_4 + IL_00bb: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00c0: pop + IL_00c1: br.s IL_00fd + + IL_00c3: ldloc.s V_4 + IL_00c5: ldc.i4.3 + IL_00c6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00cb: ldloc.0 + IL_00cc: ldloc.s V_4 + IL_00ce: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00d3: pop + IL_00d4: br.s IL_00fd + + IL_00d6: ldloc.s V_4 + IL_00d8: ldc.i4.4 + IL_00d9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch/SetProperty::set_Set(int32) + IL_00de: ldloc.0 + IL_00df: ldloc.s V_4 + IL_00e1: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00e6: pop + IL_00e7: br.s IL_00fd + + IL_00e9: ldloc.0 + IL_00ea: ldloc.s V_4 + IL_00ec: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00f1: pop + IL_00f2: br.s IL_00fd + + IL_00f4: ldloc.1 + IL_00f5: ldloc.s V_4 + IL_00f7: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object) + IL_00fc: pop + IL_00fd: ldloc.3 + IL_00fe: ldc.i4.1 + IL_00ff: add + IL_0100: stloc.3 + IL_0101: ldloc.3 + IL_0102: ldloc.2 + IL_0103: ldlen + IL_0104: conv.i4 + IL_0105: blt IL_0019 + + IL_010a: ret + } // end of method Switch::SwitchOnStringInForLoop + + .method public hidebysig static void SwitchWithComplexCondition(string[] args) cil managed + { + // Code size 139 (0x8b) + .maxstack 4 + .locals init (string V_0) + IL_0000: ldstr "a" + IL_0005: ldstr "b" + IL_000a: ldstr "c" + IL_000f: ldstr "d" + IL_0014: leave.s IL_0016 + + IL_0016: ldarg.0 + IL_0017: ldlen + IL_0018: conv.i4 + IL_0019: brfalse.s IL_0020 + + IL_001b: ldarg.0 + IL_001c: ldc.i4.0 + IL_001d: ldelem.ref + IL_001e: br.s IL_0025 + + IL_0020: ldstr "dummy" + IL_0025: dup + IL_0026: stloc.0 + IL_0027: brfalse.s IL_0080 + + IL_0029: ldloc.0 + IL_002a: call string [mscorlib]System.String::IsInterned(string) + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldstr "a" + IL_0036: beq.s IL_0052 + + IL_0038: ldloc.0 + IL_0039: ldstr "b" + IL_003e: beq.s IL_005e + + IL_0040: ldloc.0 + IL_0041: ldstr "c" + IL_0046: beq.s IL_006a + + IL_0048: ldloc.0 + IL_0049: ldstr "d" + IL_004e: beq.s IL_0076 + + IL_0050: br.s IL_0080 + + IL_0052: ldstr "a" + IL_0057: call void [mscorlib]System.Console::WriteLine(string) + IL_005c: br.s IL_0080 + + IL_005e: ldstr "b" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: br.s IL_0080 + + IL_006a: ldstr "c" + IL_006f: call void [mscorlib]System.Console::WriteLine(string) + IL_0074: br.s IL_0080 + + IL_0076: ldstr "d" + IL_007b: call void [mscorlib]System.Console::WriteLine(string) + IL_0080: ldstr "end" + IL_0085: call void [mscorlib]System.Console::WriteLine(string) + IL_008a: ret + } // end of method Switch::SwitchWithComplexCondition + + .method public hidebysig static void SwitchWithArray(string[] args) cil managed + { + // Code size 127 (0x7f) + .maxstack 4 + .locals init (string V_0) + IL_0000: ldstr "a" + IL_0005: ldstr "b" + IL_000a: ldstr "c" + IL_000f: ldstr "d" + IL_0014: leave.s IL_0016 + + IL_0016: ldarg.0 + IL_0017: ldc.i4.0 + IL_0018: ldelem.ref + IL_0019: dup + IL_001a: stloc.0 + IL_001b: brfalse.s IL_0074 + + IL_001d: ldloc.0 + IL_001e: call string [mscorlib]System.String::IsInterned(string) + IL_0023: stloc.0 + IL_0024: ldloc.0 + IL_0025: ldstr "a" + IL_002a: beq.s IL_0046 + + IL_002c: ldloc.0 + IL_002d: ldstr "b" + IL_0032: beq.s IL_0052 + + IL_0034: ldloc.0 + IL_0035: ldstr "c" + IL_003a: beq.s IL_005e + + IL_003c: ldloc.0 + IL_003d: ldstr "d" + IL_0042: beq.s IL_006a + + IL_0044: br.s IL_0074 + + IL_0046: ldstr "a" + IL_004b: call void [mscorlib]System.Console::WriteLine(string) + IL_0050: br.s IL_0074 + + IL_0052: ldstr "b" + IL_0057: call void [mscorlib]System.Console::WriteLine(string) + IL_005c: br.s IL_0074 + + IL_005e: ldstr "c" + IL_0063: call void [mscorlib]System.Console::WriteLine(string) + IL_0068: br.s IL_0074 + + IL_006a: ldstr "d" + IL_006f: call void [mscorlib]System.Console::WriteLine(string) + IL_0074: ldstr "end" + IL_0079: call void [mscorlib]System.Console::WriteLine(string) + IL_007e: ret + } // end of method Switch::SwitchWithArray + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method Switch::.ctor + +} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch + +.class private auto ansi '' + extends [mscorlib]System.Object +{ + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000006-1' + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000007-1' + .field static assembly class [mscorlib]System.Collections.Hashtable '$$method0x6000007-2' +} // end of class '' + + +// ============================================================= + +// *********** DISASSEMBLY COMPLETE *********************** +// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\TestCases\ILPretty\CS1xSwitch_Release.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.cs b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.cs new file mode 100644 index 000000000..00af4fe70 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.cs @@ -0,0 +1,12 @@ +using System; + +public sealed class EvType : MulticastDelegate +{ + +} + +[Serializable] +public class OwningClass +{ + public event EvType EvName; +} diff --git a/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.il b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.il new file mode 100644 index 000000000..777f13888 --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/ILPretty/Issue1145.il @@ -0,0 +1,83 @@ +.class public auto ansi sealed EvType extends [mscorlib]System.MulticastDelegate +{ + // Methods not included. Just the run of the mill ctor + {Begin|End}?Invoke +} + +.class public auto ansi serializable beforefieldinit OwningClass +{ + +.field class EvType EvName + +.event EvType EvName +{ + .addon instance void OwningClass::add_EvName(class EvType) + .removeon instance void OwningClass::remove_EvName(class EvType) +} + +.method public hidebysig specialname + instance void add_EvName ( + class EvType 'value' + ) cil managed +{ + .maxstack 3 + .locals init ( + [0] class EvType, + [1] class EvType + ) + + IL_0000: ldarg.0 + IL_0001: ldfld class EvType OwningClass::EvName + IL_0006: stloc.0 + // loop start (head: IL_0007) + IL_0007: ldloc.0 + IL_0008: stloc.1 + IL_0009: ldarg.0 + IL_000a: ldflda class EvType OwningClass::EvName + IL_000f: ldloc.1 + IL_0010: ldarg.1 + IL_0011: call class [mscorlib]System.Delegate [mscorlib]System.Delegate::Combine(class [mscorlib]System.Delegate, class [mscorlib]System.Delegate) + IL_0016: castclass EvType + IL_001b: ldloc.0 + IL_001c: call !!0 [mscorlib]System.Threading.Interlocked::CompareExchange(!!0&, !!0, !!0) + IL_0021: stloc.0 + IL_0022: ldloc.0 + IL_0023: ldloc.1 + IL_0024: bne.un IL_0007 + // end loop + IL_0029: ret +} // end of method OwningClass::add_EvName + +.method public hidebysig specialname + instance void remove_EvName ( + class EvType 'value' + ) cil managed +{ + .maxstack 3 + .locals init ( + [0] class EvType, + [1] class EvType + ) + + IL_0000: ldarg.0 + IL_0001: ldfld class EvType OwningClass::EvName + IL_0006: stloc.0 + // loop start (head: IL_0007) + IL_0007: ldloc.0 + IL_0008: stloc.1 + IL_0009: ldarg.0 + IL_000a: ldflda class EvType OwningClass::EvName + IL_000f: ldloc.1 + IL_0010: ldarg.1 + IL_0011: call class [mscorlib]System.Delegate [mscorlib]System.Delegate::Remove(class [mscorlib]System.Delegate, class [mscorlib]System.Delegate) + IL_0016: castclass EvType + IL_001b: ldloc.0 + IL_001c: call !!0 [mscorlib]System.Threading.Interlocked::CompareExchange(!!0&, !!0, !!0) + IL_0021: stloc.0 + IL_0022: ldloc.0 + IL_0023: ldloc.1 + IL_0024: bne.un IL_0007 + // end loop + IL_0029: ret +} // end of method OwningClass::remove_EvName + +} // end of class OwningClass \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.il index 89a374e78..aa70d27c2 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '1xvbqrhn' +.assembly AnonymousTypes { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '1xvbqrhn.dll' -// MVID: {FBEE2A5E-0EA6-4D81-AF17-0E675B5AAF7A} +.module AnonymousTypes.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02CF0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -851,4 +847,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\AnonymousTypes.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.opt.il index 147612326..71fc0af5c 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AnonymousTypes.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly ikebg3tc +.assembly AnonymousTypes.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module ikebg3tc.dll -// MVID: {9F96FB3A-745D-4BC1-8552-8ECB86372E2A} +.module AnonymousTypes.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03680000 // =============== CLASS MEMBERS DECLARATION =================== @@ -746,4 +742,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\AnonymousTypes.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.il index 71b0622ba..8d88ffc95 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '0bl3wgec' +.assembly Async { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '0bl3wgec.dll' -// MVID: {D5634CE0-620A-4F18-AC07-9132CB05EFF7} +.module Async.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00930000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1604,4 +1600,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Async.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.opt.il index 5fbbe7e85..1e6f67144 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Async.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '5wwmyl42' +.assembly Async.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '5wwmyl42.dll' -// MVID: {91D59E53-2AA6-427F-B57D-0FC8808BA12D} +.module Async.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00A20000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1433,4 +1429,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Async.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.cs index 9c069c520..6e2b5a74d 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.cs @@ -1,4 +1,6 @@ -namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty +using System; + +namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty { // TODO : maybe use single-line formatting in this case? internal class AutoProperties @@ -20,5 +22,12 @@ get; set; } = 4; + + [Obsolete("Property")] + [field: Obsolete("Field")] + public int PropertyWithAttributeOnBackingField { + get; + set; + } } } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.opt.roslyn.il index e9c2f5355..2cbd82acc 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.opt.roslyn.il @@ -44,6 +44,9 @@ .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field private static int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(string) = ( 01 00 05 46 69 65 6C 64 00 00 ) // ...Field.. .method public hidebysig specialname instance int32 get_A() cil managed { @@ -109,6 +112,29 @@ IL_0006: ret } // end of method AutoProperties::set_D + .method public hidebysig specialname instance int32 + get_PropertyWithAttributeOnBackingField() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::'k__BackingField' + IL_0006: ret + } // end of method AutoProperties::get_PropertyWithAttributeOnBackingField + + .method public hidebysig specialname instance void + set_PropertyWithAttributeOnBackingField(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::'k__BackingField' + IL_0007: ret + } // end of method AutoProperties::set_PropertyWithAttributeOnBackingField + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -155,6 +181,12 @@ .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::get_D() .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::set_D(int32) } // end of property AutoProperties::D + .property instance int32 PropertyWithAttributeOnBackingField() + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(string) = ( 01 00 08 50 72 6F 70 65 72 74 79 00 00 ) // ...Property.. + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::get_PropertyWithAttributeOnBackingField() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::set_PropertyWithAttributeOnBackingField(int32) + } // end of property AutoProperties::PropertyWithAttributeOnBackingField } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.roslyn.il index 4e0e357d5..1fec1b71f 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/AutoProperties.roslyn.il @@ -48,6 +48,10 @@ .field private static int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(string) = ( 01 00 05 46 69 65 6C 64 00 00 ) // ...Field.. .method public hidebysig specialname instance int32 get_A() cil managed { @@ -113,6 +117,29 @@ IL_0006: ret } // end of method AutoProperties::set_D + .method public hidebysig specialname instance int32 + get_PropertyWithAttributeOnBackingField() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::'k__BackingField' + IL_0006: ret + } // end of method AutoProperties::get_PropertyWithAttributeOnBackingField + + .method public hidebysig specialname instance void + set_PropertyWithAttributeOnBackingField(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::'k__BackingField' + IL_0007: ret + } // end of method AutoProperties::set_PropertyWithAttributeOnBackingField + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -160,6 +187,12 @@ .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::get_D() .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::set_D(int32) } // end of property AutoProperties::D + .property instance int32 PropertyWithAttributeOnBackingField() + { + .custom instance void [mscorlib]System.ObsoleteAttribute::.ctor(string) = ( 01 00 08 50 72 6F 70 65 72 74 79 00 00 ) // ...Property.. + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::get_PropertyWithAttributeOnBackingField() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties::set_PropertyWithAttributeOnBackingField(int32) + } // end of property AutoProperties::PropertyWithAttributeOnBackingField } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.AutoProperties diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.il index 6e94340ff..112211827 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.18020 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly rbj4xpgi +.assembly CheckedUnchecked { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module rbj4xpgi.dll -// MVID: {45787808-282D-44B8-BFE5-F8F3EF6DDA83} +.module CheckedUnchecked.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x005F0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -634,4 +630,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\CheckedUnchecked.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.opt.il index 7066cd143..bda202d27 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CheckedUnchecked.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.18020 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly j4foxgdl +.assembly CheckedUnchecked.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module j4foxgdl.dll -// MVID: {C884AA00-D1B2-4593-9A69-3DBFE92E25C4} +.module CheckedUnchecked.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02F90000 // =============== CLASS MEMBERS DECLARATION =================== @@ -548,4 +544,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\CheckedUnchecked.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.cs index 494132abc..72f66339c 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.cs @@ -75,16 +75,332 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty public Item Self; } + public class CustomClass + { + public byte ByteField; + public sbyte SbyteField; + public short ShortField; + public ushort UshortField; + public int IntField; + public uint UintField; + public long LongField; + public ulong UlongField; + public CustomClass CustomClassField; + public CustomStruct CustomStructField; + + public byte ByteProp { + get; + set; + } + public sbyte SbyteProp { + get; + set; + } + public short ShortProp { + get; + set; + } + public ushort UshortProp { + get; + set; + } + public int IntProp { + get; + set; + } + public uint UintProp { + get; + set; + } + public long LongProp { + get; + set; + } + public ulong UlongProp { + get; + set; + } + + public CustomClass CustomClassProp { + get; + set; + } + public CustomStruct CustomStructProp { + get; + set; + } + + public static CustomClass operator +(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator +(CustomClass lhs, int rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator -(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator *(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator /(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator %(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator <<(CustomClass lhs, int rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator >>(CustomClass lhs, int rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator &(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator |(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator ^(CustomClass lhs, CustomClass rhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator ++(CustomClass lhs) + { + throw new NotImplementedException(); + } + public static CustomClass operator --(CustomClass lhs) + { + throw new NotImplementedException(); + } + } + + public struct CustomStruct + { + public byte ByteField; + public sbyte SbyteField; + public short ShortField; + public ushort UshortField; + public int IntField; + public uint UintField; + public long LongField; + public ulong UlongField; + public CustomClass CustomClassField; + + public CustomClass CustomClassProp { + get; + set; + } + public byte ByteProp { + get; + set; + } + public sbyte SbyteProp { + get; + set; + } + public short ShortProp { + get; + set; + } + public ushort UshortProp { + get; + set; + } + public int IntProp { + get; + set; + } + public uint UintProp { + get; + set; + } + public long LongProp { + get; + set; + } + public ulong UlongProp { + get; + set; + } + + public static CustomStruct operator +(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator -(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator *(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator /(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator %(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator <<(CustomStruct lhs, int rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator >>(CustomStruct lhs, int rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator &(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator |(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator ^(CustomStruct lhs, CustomStruct rhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator ++(CustomStruct lhs) + { + throw new NotImplementedException(); + } + public static CustomStruct operator --(CustomStruct lhs) + { + throw new NotImplementedException(); + } + } + + public struct CustomStruct2 + { + public CustomClass CustomClassField; + public CustomStruct CustomStructField; + + public byte ByteField; + public sbyte SbyteField; + public short ShortField; + public ushort UshortField; + public int IntField; + public uint UintField; + public long LongField; + public ulong UlongField; + + public CustomClass CustomClassProp { + get; + set; + } + public CustomStruct CustomStructProp { + get; + set; + } + public byte ByteProp { + get; + set; + } + public sbyte SbyteProp { + get; + set; + } + public short ShortProp { + get; + set; + } + public ushort UshortProp { + get; + set; + } + public int IntProp { + get; + set; + } + public uint UintProp { + get; + set; + } + public long LongProp { + get; + set; + } + public ulong UlongProp { + get; + set; + } + } + private int test1; private int[] array1; private StructContainer field1; private MyEnum enumField; private Dictionary ushortDict = new Dictionary(); - private ushort ushortField; private ShortEnum shortEnumField; public static int StaticField; public static short StaticShortField; + private static CustomClass customClassField; + private static CustomStruct customStructField; + private static CustomStruct2 otherCustomStructField; + private static byte byteField; + private static sbyte sbyteField; + private static short shortField; + private static ushort ushortField; + private static int intField; + private static uint uintField; + private static long longField; + private static ulong ulongField; + + private static CustomClass CustomClassProp { + get; + set; + } + private static CustomStruct CustomStructProp { + get; + set; + } + private static byte ByteProp { + get; + set; + } + private static sbyte SbyteProp { + get; + set; + } + private static short ShortProp { + get; + set; + } + private static ushort UshortProp { + get; + set; + } + private static int IntProp { + get; + set; + } + private static uint UintProp { + get; + set; + } + private static long LongProp { + get; + set; + } + private static ulong UlongProp { + get; + set; + } + public static int StaticProperty { get; set; @@ -95,6 +411,73 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty set; } +#if CS70 + private static ref CustomStruct2 GetStruct() + { + throw new NotImplementedException(); + } + + private static ref CustomStruct GetRefCustomStruct() + { + throw new NotImplementedException(); + } + + private static ref CustomClass GetRefCustomClass() + { + throw new NotImplementedException(); + } + + private static ref byte GetRefByte() + { + throw new NotImplementedException(); + } + + private static ref sbyte GetRefSbyte() + { + throw new NotImplementedException(); + } + + private static ref short GetRefShort() + { + throw new NotImplementedException(); + } + + private static ref int GetRefInt() + { + throw new NotImplementedException(); + } + + private static ref long GetRefLong() + { + throw new NotImplementedException(); + } + + private static ref ushort GetRefUshort() + { + throw new NotImplementedException(); + } + + private static ref uint GetRefUint() + { + throw new NotImplementedException(); + } + + private static ref ulong GetRefUlong() + { + throw new NotImplementedException(); + } +#endif + + private static CustomClass GetClass() + { + throw new NotImplementedException(); + } + + private static void X(T result) + { + + } + private MutableClass M() { return new MutableClass(); @@ -495,7 +878,3638 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty { StaticShortProperty++; } - + + #region Generated Tests + + public static void ByteAddTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p += 5; + //l += 5; + byteField += 5; + ByteProp += 5; + c.ByteField += 5; + c.ByteProp += 5; + s.ByteField += 5; + s.ByteProp += 5; + customClassField.ByteField += 5; + customClassField.ByteProp += 5; + otherCustomStructField.ByteField += 5; + otherCustomStructField.ByteProp += 5; + CustomClassProp.ByteField += 5; + CustomClassProp.ByteProp += 5; + GetClass().ByteField += 5; + GetClass().ByteProp += 5; +#if CS70 + GetStruct().ByteField += 5; + GetStruct().ByteProp += 5; + GetRefByte() += 5; +#endif + } + + public static void ByteSubtractTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p -= 5; + //l -= 5; + byteField -= 5; + ByteProp -= 5; + c.ByteField -= 5; + c.ByteProp -= 5; + s.ByteField -= 5; + s.ByteProp -= 5; + customClassField.ByteField -= 5; + customClassField.ByteProp -= 5; + otherCustomStructField.ByteField -= 5; + otherCustomStructField.ByteProp -= 5; + CustomClassProp.ByteField -= 5; + CustomClassProp.ByteProp -= 5; + GetClass().ByteField -= 5; + GetClass().ByteProp -= 5; +#if CS70 + GetStruct().ByteField -= 5; + GetStruct().ByteProp -= 5; + GetRefByte() -= 5; +#endif + } + + public static void ByteMultiplyTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p *= 5; + //l *= 5; + byteField *= 5; + ByteProp *= 5; + c.ByteField *= 5; + c.ByteProp *= 5; + s.ByteField *= 5; + s.ByteProp *= 5; + customClassField.ByteField *= 5; + customClassField.ByteProp *= 5; + otherCustomStructField.ByteField *= 5; + otherCustomStructField.ByteProp *= 5; + CustomClassProp.ByteField *= 5; + CustomClassProp.ByteProp *= 5; + GetClass().ByteField *= 5; + GetClass().ByteProp *= 5; +#if CS70 + GetStruct().ByteField *= 5; + GetStruct().ByteProp *= 5; + GetRefByte() *= 5; +#endif + } + + public static void ByteDivideTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p /= 5; + //l /= 5; + byteField /= 5; + ByteProp /= 5; + c.ByteField /= 5; + c.ByteProp /= 5; + s.ByteField /= 5; + s.ByteProp /= 5; + customClassField.ByteField /= 5; + customClassField.ByteProp /= 5; + otherCustomStructField.ByteField /= 5; + otherCustomStructField.ByteProp /= 5; + CustomClassProp.ByteField /= 5; + CustomClassProp.ByteProp /= 5; + GetClass().ByteField /= 5; + GetClass().ByteProp /= 5; +#if CS70 + GetStruct().ByteField /= 5; + GetStruct().ByteProp /= 5; + GetRefByte() /= 5; +#endif + } + + public static void ByteModulusTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p %= 5; + //l %= 5; + byteField %= 5; + ByteProp %= 5; + c.ByteField %= 5; + c.ByteProp %= 5; + s.ByteField %= 5; + s.ByteProp %= 5; + customClassField.ByteField %= 5; + customClassField.ByteProp %= 5; + otherCustomStructField.ByteField %= 5; + otherCustomStructField.ByteProp %= 5; + CustomClassProp.ByteField %= 5; + CustomClassProp.ByteProp %= 5; + GetClass().ByteField %= 5; + GetClass().ByteProp %= 5; +#if CS70 + GetStruct().ByteField %= 5; + GetStruct().ByteProp %= 5; + GetRefByte() %= 5; +#endif + } + + public static void ByteLeftShiftTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p <<= 5; + //l <<= 5; + byteField <<= 5; + ByteProp <<= 5; + c.ByteField <<= 5; + c.ByteProp <<= 5; + s.ByteField <<= 5; + s.ByteProp <<= 5; + customClassField.ByteField <<= 5; + customClassField.ByteProp <<= 5; + otherCustomStructField.ByteField <<= 5; + otherCustomStructField.ByteProp <<= 5; + CustomClassProp.ByteField <<= 5; + CustomClassProp.ByteProp <<= 5; + GetClass().ByteField <<= 5; + GetClass().ByteProp <<= 5; +#if CS70 + GetStruct().ByteField <<= 5; + GetStruct().ByteProp <<= 5; + GetRefByte() <<= 5; +#endif + } + + public static void ByteRightShiftTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p >>= 5; + //l >>= 5; + byteField >>= 5; + ByteProp >>= 5; + c.ByteField >>= 5; + c.ByteProp >>= 5; + s.ByteField >>= 5; + s.ByteProp >>= 5; + customClassField.ByteField >>= 5; + customClassField.ByteProp >>= 5; + otherCustomStructField.ByteField >>= 5; + otherCustomStructField.ByteProp >>= 5; + CustomClassProp.ByteField >>= 5; + CustomClassProp.ByteProp >>= 5; + GetClass().ByteField >>= 5; + GetClass().ByteProp >>= 5; +#if CS70 + GetStruct().ByteField >>= 5; + GetStruct().ByteProp >>= 5; + GetRefByte() >>= 5; +#endif + } + + public static void ByteBitAndTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p &= 5; + //l &= 5; + byteField &= 5; + ByteProp &= 5; + c.ByteField &= 5; + c.ByteProp &= 5; + s.ByteField &= 5; + s.ByteProp &= 5; + customClassField.ByteField &= 5; + customClassField.ByteProp &= 5; + otherCustomStructField.ByteField &= 5; + otherCustomStructField.ByteProp &= 5; + CustomClassProp.ByteField &= 5; + CustomClassProp.ByteProp &= 5; + GetClass().ByteField &= 5; + GetClass().ByteProp &= 5; +#if CS70 + GetStruct().ByteField &= 5; + GetStruct().ByteProp &= 5; + GetRefByte() &= 5; +#endif + } + + public static void ByteBitOrTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p |= 5; + //l |= 5; + byteField |= 5; + ByteProp |= 5; + c.ByteField |= 5; + c.ByteProp |= 5; + s.ByteField |= 5; + s.ByteProp |= 5; + customClassField.ByteField |= 5; + customClassField.ByteProp |= 5; + otherCustomStructField.ByteField |= 5; + otherCustomStructField.ByteProp |= 5; + CustomClassProp.ByteField |= 5; + CustomClassProp.ByteProp |= 5; + GetClass().ByteField |= 5; + GetClass().ByteProp |= 5; +#if CS70 + GetStruct().ByteField |= 5; + GetStruct().ByteProp |= 5; + GetRefByte() |= 5; +#endif + } + + public static void ByteBitXorTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //p ^= 5; + //l ^= 5; + byteField ^= 5; + ByteProp ^= 5; + c.ByteField ^= 5; + c.ByteProp ^= 5; + s.ByteField ^= 5; + s.ByteProp ^= 5; + customClassField.ByteField ^= 5; + customClassField.ByteProp ^= 5; + otherCustomStructField.ByteField ^= 5; + otherCustomStructField.ByteProp ^= 5; + CustomClassProp.ByteField ^= 5; + CustomClassProp.ByteProp ^= 5; + GetClass().ByteField ^= 5; + GetClass().ByteProp ^= 5; +#if CS70 + GetStruct().ByteField ^= 5; + GetStruct().ByteProp ^= 5; + GetRefByte() ^= 5; +#endif + } + + public static void BytePostIncTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //X(p++); + //X(l++); + X(byteField++); + X(ByteProp++); + X(c.ByteField++); + X(c.ByteProp++); + X(s.ByteField++); + X(s.ByteProp++); + X(customClassField.ByteField++); + X(customClassField.ByteProp++); + X(otherCustomStructField.ByteField++); + X(otherCustomStructField.ByteProp++); + X(CustomClassProp.ByteField++); + X(CustomClassProp.ByteProp++); + X(GetClass().ByteField++); + X(GetClass().ByteProp++); +#if CS70 + X(GetStruct().ByteField++); + X(GetStruct().ByteProp++); + X(GetRefByte()++); +#endif + } + + public static void BytePreIncTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //X(++p); + //X(++l); + X(++byteField); + X(++ByteProp); + X(++c.ByteField); + X(++c.ByteProp); + X(++s.ByteField); + X(++s.ByteProp); + X(++customClassField.ByteField); + X(++customClassField.ByteProp); + X(++otherCustomStructField.ByteField); + X(++otherCustomStructField.ByteProp); + X(++CustomClassProp.ByteField); + X(++CustomClassProp.ByteProp); + X(++GetClass().ByteField); + X(++GetClass().ByteProp); +#if CS70 + X(++GetStruct().ByteField); + X(++GetStruct().ByteProp); + X(++GetRefByte()); +#endif + } + public static void BytePostDecTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //X(p--); + //X(l--); + X(byteField--); + X(ByteProp--); + X(c.ByteField--); + X(c.ByteProp--); + X(s.ByteField--); + X(s.ByteProp--); + X(customClassField.ByteField--); + X(customClassField.ByteProp--); + X(otherCustomStructField.ByteField--); + X(otherCustomStructField.ByteProp--); + X(CustomClassProp.ByteField--); + X(CustomClassProp.ByteProp--); + X(GetClass().ByteField--); + X(GetClass().ByteProp--); +#if CS70 + X(GetStruct().ByteField--); + X(GetStruct().ByteProp--); + X(GetRefByte()--); +#endif + } + + public static void BytePreDecTest(byte p, CustomClass c, CustomStruct2 s) + { + //byte l = 0; + //X(--p); + //X(--l); + X(--byteField); + X(--ByteProp); + X(--c.ByteField); + X(--c.ByteProp); + X(--s.ByteField); + X(--s.ByteProp); + X(--customClassField.ByteField); + X(--customClassField.ByteProp); + X(--otherCustomStructField.ByteField); + X(--otherCustomStructField.ByteProp); + X(--CustomClassProp.ByteField); + X(--CustomClassProp.ByteProp); + X(--GetClass().ByteField); + X(--GetClass().ByteProp); +#if CS70 + X(--GetStruct().ByteField); + X(--GetStruct().ByteProp); + X(--GetRefByte()); +#endif + } + public static void SbyteAddTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p += 5; + //l += 5; + sbyteField += 5; + SbyteProp += 5; + c.SbyteField += 5; + c.SbyteProp += 5; + s.SbyteField += 5; + s.SbyteProp += 5; + customClassField.SbyteField += 5; + customClassField.SbyteProp += 5; + otherCustomStructField.SbyteField += 5; + otherCustomStructField.SbyteProp += 5; + CustomClassProp.SbyteField += 5; + CustomClassProp.SbyteProp += 5; + GetClass().SbyteField += 5; + GetClass().SbyteProp += 5; +#if CS70 + GetStruct().SbyteField += 5; + GetStruct().SbyteProp += 5; + GetRefSbyte() += 5; +#endif + } + + public static void SbyteSubtractTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p -= 5; + //l -= 5; + sbyteField -= 5; + SbyteProp -= 5; + c.SbyteField -= 5; + c.SbyteProp -= 5; + s.SbyteField -= 5; + s.SbyteProp -= 5; + customClassField.SbyteField -= 5; + customClassField.SbyteProp -= 5; + otherCustomStructField.SbyteField -= 5; + otherCustomStructField.SbyteProp -= 5; + CustomClassProp.SbyteField -= 5; + CustomClassProp.SbyteProp -= 5; + GetClass().SbyteField -= 5; + GetClass().SbyteProp -= 5; +#if CS70 + GetStruct().SbyteField -= 5; + GetStruct().SbyteProp -= 5; + GetRefSbyte() -= 5; +#endif + } + + public static void SbyteMultiplyTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p *= 5; + //l *= 5; + sbyteField *= 5; + SbyteProp *= 5; + c.SbyteField *= 5; + c.SbyteProp *= 5; + s.SbyteField *= 5; + s.SbyteProp *= 5; + customClassField.SbyteField *= 5; + customClassField.SbyteProp *= 5; + otherCustomStructField.SbyteField *= 5; + otherCustomStructField.SbyteProp *= 5; + CustomClassProp.SbyteField *= 5; + CustomClassProp.SbyteProp *= 5; + GetClass().SbyteField *= 5; + GetClass().SbyteProp *= 5; +#if CS70 + GetStruct().SbyteField *= 5; + GetStruct().SbyteProp *= 5; + GetRefSbyte() *= 5; +#endif + } + + public static void SbyteDivideTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p /= 5; + //l /= 5; + sbyteField /= 5; + SbyteProp /= 5; + c.SbyteField /= 5; + c.SbyteProp /= 5; + s.SbyteField /= 5; + s.SbyteProp /= 5; + customClassField.SbyteField /= 5; + customClassField.SbyteProp /= 5; + otherCustomStructField.SbyteField /= 5; + otherCustomStructField.SbyteProp /= 5; + CustomClassProp.SbyteField /= 5; + CustomClassProp.SbyteProp /= 5; + GetClass().SbyteField /= 5; + GetClass().SbyteProp /= 5; +#if CS70 + GetStruct().SbyteField /= 5; + GetStruct().SbyteProp /= 5; + GetRefSbyte() /= 5; +#endif + } + + public static void SbyteModulusTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p %= 5; + //l %= 5; + sbyteField %= 5; + SbyteProp %= 5; + c.SbyteField %= 5; + c.SbyteProp %= 5; + s.SbyteField %= 5; + s.SbyteProp %= 5; + customClassField.SbyteField %= 5; + customClassField.SbyteProp %= 5; + otherCustomStructField.SbyteField %= 5; + otherCustomStructField.SbyteProp %= 5; + CustomClassProp.SbyteField %= 5; + CustomClassProp.SbyteProp %= 5; + GetClass().SbyteField %= 5; + GetClass().SbyteProp %= 5; +#if CS70 + GetStruct().SbyteField %= 5; + GetStruct().SbyteProp %= 5; + GetRefSbyte() %= 5; +#endif + } + + public static void SbyteLeftShiftTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p <<= 5; + //l <<= 5; + sbyteField <<= 5; + SbyteProp <<= 5; + c.SbyteField <<= 5; + c.SbyteProp <<= 5; + s.SbyteField <<= 5; + s.SbyteProp <<= 5; + customClassField.SbyteField <<= 5; + customClassField.SbyteProp <<= 5; + otherCustomStructField.SbyteField <<= 5; + otherCustomStructField.SbyteProp <<= 5; + CustomClassProp.SbyteField <<= 5; + CustomClassProp.SbyteProp <<= 5; + GetClass().SbyteField <<= 5; + GetClass().SbyteProp <<= 5; +#if CS70 + GetStruct().SbyteField <<= 5; + GetStruct().SbyteProp <<= 5; + GetRefSbyte() <<= 5; +#endif + } + + public static void SbyteRightShiftTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p >>= 5; + //l >>= 5; + sbyteField >>= 5; + SbyteProp >>= 5; + c.SbyteField >>= 5; + c.SbyteProp >>= 5; + s.SbyteField >>= 5; + s.SbyteProp >>= 5; + customClassField.SbyteField >>= 5; + customClassField.SbyteProp >>= 5; + otherCustomStructField.SbyteField >>= 5; + otherCustomStructField.SbyteProp >>= 5; + CustomClassProp.SbyteField >>= 5; + CustomClassProp.SbyteProp >>= 5; + GetClass().SbyteField >>= 5; + GetClass().SbyteProp >>= 5; +#if CS70 + GetStruct().SbyteField >>= 5; + GetStruct().SbyteProp >>= 5; + GetRefSbyte() >>= 5; +#endif + } + + public static void SbyteBitAndTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p &= 5; + //l &= 5; + sbyteField &= 5; + SbyteProp &= 5; + c.SbyteField &= 5; + c.SbyteProp &= 5; + s.SbyteField &= 5; + s.SbyteProp &= 5; + customClassField.SbyteField &= 5; + customClassField.SbyteProp &= 5; + otherCustomStructField.SbyteField &= 5; + otherCustomStructField.SbyteProp &= 5; + CustomClassProp.SbyteField &= 5; + CustomClassProp.SbyteProp &= 5; + GetClass().SbyteField &= 5; + GetClass().SbyteProp &= 5; +#if CS70 + GetStruct().SbyteField &= 5; + GetStruct().SbyteProp &= 5; + GetRefSbyte() &= 5; +#endif + } + + public static void SbyteBitOrTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p |= 5; + //l |= 5; + sbyteField |= 5; + SbyteProp |= 5; + c.SbyteField |= 5; + c.SbyteProp |= 5; + s.SbyteField |= 5; + s.SbyteProp |= 5; + customClassField.SbyteField |= 5; + customClassField.SbyteProp |= 5; + otherCustomStructField.SbyteField |= 5; + otherCustomStructField.SbyteProp |= 5; + CustomClassProp.SbyteField |= 5; + CustomClassProp.SbyteProp |= 5; + GetClass().SbyteField |= 5; + GetClass().SbyteProp |= 5; +#if CS70 + GetStruct().SbyteField |= 5; + GetStruct().SbyteProp |= 5; + GetRefSbyte() |= 5; +#endif + } + + public static void SbyteBitXorTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //p ^= 5; + //l ^= 5; + sbyteField ^= 5; + SbyteProp ^= 5; + c.SbyteField ^= 5; + c.SbyteProp ^= 5; + s.SbyteField ^= 5; + s.SbyteProp ^= 5; + customClassField.SbyteField ^= 5; + customClassField.SbyteProp ^= 5; + otherCustomStructField.SbyteField ^= 5; + otherCustomStructField.SbyteProp ^= 5; + CustomClassProp.SbyteField ^= 5; + CustomClassProp.SbyteProp ^= 5; + GetClass().SbyteField ^= 5; + GetClass().SbyteProp ^= 5; +#if CS70 + GetStruct().SbyteField ^= 5; + GetStruct().SbyteProp ^= 5; + GetRefSbyte() ^= 5; +#endif + } + + public static void SbytePostIncTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //X(p++); + //X(l++); + X(sbyteField++); + X(SbyteProp++); + X(c.SbyteField++); + X(c.SbyteProp++); + X(s.SbyteField++); + X(s.SbyteProp++); + X(customClassField.SbyteField++); + X(customClassField.SbyteProp++); + X(otherCustomStructField.SbyteField++); + X(otherCustomStructField.SbyteProp++); + X(CustomClassProp.SbyteField++); + X(CustomClassProp.SbyteProp++); + X(GetClass().SbyteField++); + X(GetClass().SbyteProp++); +#if CS70 + X(GetStruct().SbyteField++); + X(GetStruct().SbyteProp++); + X(GetRefSbyte()++); +#endif + } + + public static void SbytePreIncTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //X(++p); + //X(++l); + X(++sbyteField); + X(++SbyteProp); + X(++c.SbyteField); + X(++c.SbyteProp); + X(++s.SbyteField); + X(++s.SbyteProp); + X(++customClassField.SbyteField); + X(++customClassField.SbyteProp); + X(++otherCustomStructField.SbyteField); + X(++otherCustomStructField.SbyteProp); + X(++CustomClassProp.SbyteField); + X(++CustomClassProp.SbyteProp); + X(++GetClass().SbyteField); + X(++GetClass().SbyteProp); +#if CS70 + X(++GetStruct().SbyteField); + X(++GetStruct().SbyteProp); + X(++GetRefSbyte()); +#endif + } + public static void SbytePostDecTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //X(p--); + //X(l--); + X(sbyteField--); + X(SbyteProp--); + X(c.SbyteField--); + X(c.SbyteProp--); + X(s.SbyteField--); + X(s.SbyteProp--); + X(customClassField.SbyteField--); + X(customClassField.SbyteProp--); + X(otherCustomStructField.SbyteField--); + X(otherCustomStructField.SbyteProp--); + X(CustomClassProp.SbyteField--); + X(CustomClassProp.SbyteProp--); + X(GetClass().SbyteField--); + X(GetClass().SbyteProp--); +#if CS70 + X(GetStruct().SbyteField--); + X(GetStruct().SbyteProp--); + X(GetRefSbyte()--); +#endif + } + + public static void SbytePreDecTest(sbyte p, CustomClass c, CustomStruct2 s) + { + //sbyte l = 0; + //X(--p); + //X(--l); + X(--sbyteField); + X(--SbyteProp); + X(--c.SbyteField); + X(--c.SbyteProp); + X(--s.SbyteField); + X(--s.SbyteProp); + X(--customClassField.SbyteField); + X(--customClassField.SbyteProp); + X(--otherCustomStructField.SbyteField); + X(--otherCustomStructField.SbyteProp); + X(--CustomClassProp.SbyteField); + X(--CustomClassProp.SbyteProp); + X(--GetClass().SbyteField); + X(--GetClass().SbyteProp); +#if CS70 + X(--GetStruct().SbyteField); + X(--GetStruct().SbyteProp); + X(--GetRefSbyte()); +#endif + } + public static void ShortAddTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p += 5; + //l += 5; + shortField += 5; + ShortProp += 5; + c.ShortField += 5; + c.ShortProp += 5; + s.ShortField += 5; + s.ShortProp += 5; + customClassField.ShortField += 5; + customClassField.ShortProp += 5; + otherCustomStructField.ShortField += 5; + otherCustomStructField.ShortProp += 5; + CustomClassProp.ShortField += 5; + CustomClassProp.ShortProp += 5; + GetClass().ShortField += 5; + GetClass().ShortProp += 5; +#if CS70 + GetStruct().ShortField += 5; + GetStruct().ShortProp += 5; + GetRefShort() += 5; +#endif + } + + public static void ShortSubtractTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p -= 5; + //l -= 5; + shortField -= 5; + ShortProp -= 5; + c.ShortField -= 5; + c.ShortProp -= 5; + s.ShortField -= 5; + s.ShortProp -= 5; + customClassField.ShortField -= 5; + customClassField.ShortProp -= 5; + otherCustomStructField.ShortField -= 5; + otherCustomStructField.ShortProp -= 5; + CustomClassProp.ShortField -= 5; + CustomClassProp.ShortProp -= 5; + GetClass().ShortField -= 5; + GetClass().ShortProp -= 5; +#if CS70 + GetStruct().ShortField -= 5; + GetStruct().ShortProp -= 5; + GetRefShort() -= 5; +#endif + } + + public static void ShortMultiplyTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p *= 5; + //l *= 5; + shortField *= 5; + ShortProp *= 5; + c.ShortField *= 5; + c.ShortProp *= 5; + s.ShortField *= 5; + s.ShortProp *= 5; + customClassField.ShortField *= 5; + customClassField.ShortProp *= 5; + otherCustomStructField.ShortField *= 5; + otherCustomStructField.ShortProp *= 5; + CustomClassProp.ShortField *= 5; + CustomClassProp.ShortProp *= 5; + GetClass().ShortField *= 5; + GetClass().ShortProp *= 5; +#if CS70 + GetStruct().ShortField *= 5; + GetStruct().ShortProp *= 5; + GetRefShort() *= 5; +#endif + } + + public static void ShortDivideTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p /= 5; + //l /= 5; + shortField /= 5; + ShortProp /= 5; + c.ShortField /= 5; + c.ShortProp /= 5; + s.ShortField /= 5; + s.ShortProp /= 5; + customClassField.ShortField /= 5; + customClassField.ShortProp /= 5; + otherCustomStructField.ShortField /= 5; + otherCustomStructField.ShortProp /= 5; + CustomClassProp.ShortField /= 5; + CustomClassProp.ShortProp /= 5; + GetClass().ShortField /= 5; + GetClass().ShortProp /= 5; +#if CS70 + GetStruct().ShortField /= 5; + GetStruct().ShortProp /= 5; + GetRefShort() /= 5; +#endif + } + + public static void ShortModulusTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p %= 5; + //l %= 5; + shortField %= 5; + ShortProp %= 5; + c.ShortField %= 5; + c.ShortProp %= 5; + s.ShortField %= 5; + s.ShortProp %= 5; + customClassField.ShortField %= 5; + customClassField.ShortProp %= 5; + otherCustomStructField.ShortField %= 5; + otherCustomStructField.ShortProp %= 5; + CustomClassProp.ShortField %= 5; + CustomClassProp.ShortProp %= 5; + GetClass().ShortField %= 5; + GetClass().ShortProp %= 5; +#if CS70 + GetStruct().ShortField %= 5; + GetStruct().ShortProp %= 5; + GetRefShort() %= 5; +#endif + } + + public static void ShortLeftShiftTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p <<= 5; + //l <<= 5; + shortField <<= 5; + ShortProp <<= 5; + c.ShortField <<= 5; + c.ShortProp <<= 5; + s.ShortField <<= 5; + s.ShortProp <<= 5; + customClassField.ShortField <<= 5; + customClassField.ShortProp <<= 5; + otherCustomStructField.ShortField <<= 5; + otherCustomStructField.ShortProp <<= 5; + CustomClassProp.ShortField <<= 5; + CustomClassProp.ShortProp <<= 5; + GetClass().ShortField <<= 5; + GetClass().ShortProp <<= 5; +#if CS70 + GetStruct().ShortField <<= 5; + GetStruct().ShortProp <<= 5; + GetRefShort() <<= 5; +#endif + } + + public static void ShortRightShiftTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p >>= 5; + //l >>= 5; + shortField >>= 5; + ShortProp >>= 5; + c.ShortField >>= 5; + c.ShortProp >>= 5; + s.ShortField >>= 5; + s.ShortProp >>= 5; + customClassField.ShortField >>= 5; + customClassField.ShortProp >>= 5; + otherCustomStructField.ShortField >>= 5; + otherCustomStructField.ShortProp >>= 5; + CustomClassProp.ShortField >>= 5; + CustomClassProp.ShortProp >>= 5; + GetClass().ShortField >>= 5; + GetClass().ShortProp >>= 5; +#if CS70 + GetStruct().ShortField >>= 5; + GetStruct().ShortProp >>= 5; + GetRefShort() >>= 5; +#endif + } + + public static void ShortBitAndTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p &= 5; + //l &= 5; + shortField &= 5; + ShortProp &= 5; + c.ShortField &= 5; + c.ShortProp &= 5; + s.ShortField &= 5; + s.ShortProp &= 5; + customClassField.ShortField &= 5; + customClassField.ShortProp &= 5; + otherCustomStructField.ShortField &= 5; + otherCustomStructField.ShortProp &= 5; + CustomClassProp.ShortField &= 5; + CustomClassProp.ShortProp &= 5; + GetClass().ShortField &= 5; + GetClass().ShortProp &= 5; +#if CS70 + GetStruct().ShortField &= 5; + GetStruct().ShortProp &= 5; + GetRefShort() &= 5; +#endif + } + + public static void ShortBitOrTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p |= 5; + //l |= 5; + shortField |= 5; + ShortProp |= 5; + c.ShortField |= 5; + c.ShortProp |= 5; + s.ShortField |= 5; + s.ShortProp |= 5; + customClassField.ShortField |= 5; + customClassField.ShortProp |= 5; + otherCustomStructField.ShortField |= 5; + otherCustomStructField.ShortProp |= 5; + CustomClassProp.ShortField |= 5; + CustomClassProp.ShortProp |= 5; + GetClass().ShortField |= 5; + GetClass().ShortProp |= 5; +#if CS70 + GetStruct().ShortField |= 5; + GetStruct().ShortProp |= 5; + GetRefShort() |= 5; +#endif + } + + public static void ShortBitXorTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //p ^= 5; + //l ^= 5; + shortField ^= 5; + ShortProp ^= 5; + c.ShortField ^= 5; + c.ShortProp ^= 5; + s.ShortField ^= 5; + s.ShortProp ^= 5; + customClassField.ShortField ^= 5; + customClassField.ShortProp ^= 5; + otherCustomStructField.ShortField ^= 5; + otherCustomStructField.ShortProp ^= 5; + CustomClassProp.ShortField ^= 5; + CustomClassProp.ShortProp ^= 5; + GetClass().ShortField ^= 5; + GetClass().ShortProp ^= 5; +#if CS70 + GetStruct().ShortField ^= 5; + GetStruct().ShortProp ^= 5; + GetRefShort() ^= 5; +#endif + } + + public static void ShortPostIncTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //X(p++); + //X(l++); + X(shortField++); + X(ShortProp++); + X(c.ShortField++); + X(c.ShortProp++); + X(s.ShortField++); + X(s.ShortProp++); + X(customClassField.ShortField++); + X(customClassField.ShortProp++); + X(otherCustomStructField.ShortField++); + X(otherCustomStructField.ShortProp++); + X(CustomClassProp.ShortField++); + X(CustomClassProp.ShortProp++); + X(GetClass().ShortField++); + X(GetClass().ShortProp++); +#if CS70 + X(GetStruct().ShortField++); + X(GetStruct().ShortProp++); + X(GetRefShort()++); +#endif + } + + public static void ShortPreIncTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //X(++p); + //X(++l); + X(++shortField); + X(++ShortProp); + X(++c.ShortField); + X(++c.ShortProp); + X(++s.ShortField); + X(++s.ShortProp); + X(++customClassField.ShortField); + X(++customClassField.ShortProp); + X(++otherCustomStructField.ShortField); + X(++otherCustomStructField.ShortProp); + X(++CustomClassProp.ShortField); + X(++CustomClassProp.ShortProp); + X(++GetClass().ShortField); + X(++GetClass().ShortProp); +#if CS70 + X(++GetStruct().ShortField); + X(++GetStruct().ShortProp); + X(++GetRefShort()); +#endif + } + public static void ShortPostDecTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //X(p--); + //X(l--); + X(shortField--); + X(ShortProp--); + X(c.ShortField--); + X(c.ShortProp--); + X(s.ShortField--); + X(s.ShortProp--); + X(customClassField.ShortField--); + X(customClassField.ShortProp--); + X(otherCustomStructField.ShortField--); + X(otherCustomStructField.ShortProp--); + X(CustomClassProp.ShortField--); + X(CustomClassProp.ShortProp--); + X(GetClass().ShortField--); + X(GetClass().ShortProp--); +#if CS70 + X(GetStruct().ShortField--); + X(GetStruct().ShortProp--); + X(GetRefShort()--); +#endif + } + + public static void ShortPreDecTest(short p, CustomClass c, CustomStruct2 s) + { + //short l = 0; + //X(--p); + //X(--l); + X(--shortField); + X(--ShortProp); + X(--c.ShortField); + X(--c.ShortProp); + X(--s.ShortField); + X(--s.ShortProp); + X(--customClassField.ShortField); + X(--customClassField.ShortProp); + X(--otherCustomStructField.ShortField); + X(--otherCustomStructField.ShortProp); + X(--CustomClassProp.ShortField); + X(--CustomClassProp.ShortProp); + X(--GetClass().ShortField); + X(--GetClass().ShortProp); +#if CS70 + X(--GetStruct().ShortField); + X(--GetStruct().ShortProp); + X(--GetRefShort()); +#endif + } + public static void UshortAddTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p += 5; + //l += 5; + ushortField += 5; + UshortProp += 5; + c.UshortField += 5; + c.UshortProp += 5; + s.UshortField += 5; + s.UshortProp += 5; + customClassField.UshortField += 5; + customClassField.UshortProp += 5; + otherCustomStructField.UshortField += 5; + otherCustomStructField.UshortProp += 5; + CustomClassProp.UshortField += 5; + CustomClassProp.UshortProp += 5; + GetClass().UshortField += 5; + GetClass().UshortProp += 5; +#if CS70 + GetStruct().UshortField += 5; + GetStruct().UshortProp += 5; + GetRefUshort() += 5; +#endif + } + + public static void UshortSubtractTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p -= 5; + //l -= 5; + ushortField -= 5; + UshortProp -= 5; + c.UshortField -= 5; + c.UshortProp -= 5; + s.UshortField -= 5; + s.UshortProp -= 5; + customClassField.UshortField -= 5; + customClassField.UshortProp -= 5; + otherCustomStructField.UshortField -= 5; + otherCustomStructField.UshortProp -= 5; + CustomClassProp.UshortField -= 5; + CustomClassProp.UshortProp -= 5; + GetClass().UshortField -= 5; + GetClass().UshortProp -= 5; +#if CS70 + GetStruct().UshortField -= 5; + GetStruct().UshortProp -= 5; + GetRefUshort() -= 5; +#endif + } + + public static void UshortMultiplyTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p *= 5; + //l *= 5; + ushortField *= 5; + UshortProp *= 5; + c.UshortField *= 5; + c.UshortProp *= 5; + s.UshortField *= 5; + s.UshortProp *= 5; + customClassField.UshortField *= 5; + customClassField.UshortProp *= 5; + otherCustomStructField.UshortField *= 5; + otherCustomStructField.UshortProp *= 5; + CustomClassProp.UshortField *= 5; + CustomClassProp.UshortProp *= 5; + GetClass().UshortField *= 5; + GetClass().UshortProp *= 5; +#if CS70 + GetStruct().UshortField *= 5; + GetStruct().UshortProp *= 5; + GetRefUshort() *= 5; +#endif + } + + public static void UshortDivideTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p /= 5; + //l /= 5; + ushortField /= 5; + UshortProp /= 5; + c.UshortField /= 5; + c.UshortProp /= 5; + s.UshortField /= 5; + s.UshortProp /= 5; + customClassField.UshortField /= 5; + customClassField.UshortProp /= 5; + otherCustomStructField.UshortField /= 5; + otherCustomStructField.UshortProp /= 5; + CustomClassProp.UshortField /= 5; + CustomClassProp.UshortProp /= 5; + GetClass().UshortField /= 5; + GetClass().UshortProp /= 5; +#if CS70 + GetStruct().UshortField /= 5; + GetStruct().UshortProp /= 5; + GetRefUshort() /= 5; +#endif + } + + public static void UshortModulusTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p %= 5; + //l %= 5; + ushortField %= 5; + UshortProp %= 5; + c.UshortField %= 5; + c.UshortProp %= 5; + s.UshortField %= 5; + s.UshortProp %= 5; + customClassField.UshortField %= 5; + customClassField.UshortProp %= 5; + otherCustomStructField.UshortField %= 5; + otherCustomStructField.UshortProp %= 5; + CustomClassProp.UshortField %= 5; + CustomClassProp.UshortProp %= 5; + GetClass().UshortField %= 5; + GetClass().UshortProp %= 5; +#if CS70 + GetStruct().UshortField %= 5; + GetStruct().UshortProp %= 5; + GetRefUshort() %= 5; +#endif + } + + public static void UshortLeftShiftTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p <<= 5; + //l <<= 5; + ushortField <<= 5; + UshortProp <<= 5; + c.UshortField <<= 5; + c.UshortProp <<= 5; + s.UshortField <<= 5; + s.UshortProp <<= 5; + customClassField.UshortField <<= 5; + customClassField.UshortProp <<= 5; + otherCustomStructField.UshortField <<= 5; + otherCustomStructField.UshortProp <<= 5; + CustomClassProp.UshortField <<= 5; + CustomClassProp.UshortProp <<= 5; + GetClass().UshortField <<= 5; + GetClass().UshortProp <<= 5; +#if CS70 + GetStruct().UshortField <<= 5; + GetStruct().UshortProp <<= 5; + GetRefUshort() <<= 5; +#endif + } + + public static void UshortRightShiftTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p >>= 5; + //l >>= 5; + ushortField >>= 5; + UshortProp >>= 5; + c.UshortField >>= 5; + c.UshortProp >>= 5; + s.UshortField >>= 5; + s.UshortProp >>= 5; + customClassField.UshortField >>= 5; + customClassField.UshortProp >>= 5; + otherCustomStructField.UshortField >>= 5; + otherCustomStructField.UshortProp >>= 5; + CustomClassProp.UshortField >>= 5; + CustomClassProp.UshortProp >>= 5; + GetClass().UshortField >>= 5; + GetClass().UshortProp >>= 5; +#if CS70 + GetStruct().UshortField >>= 5; + GetStruct().UshortProp >>= 5; + GetRefUshort() >>= 5; +#endif + } + + public static void UshortBitAndTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p &= 5; + //l &= 5; + ushortField &= 5; + UshortProp &= 5; + c.UshortField &= 5; + c.UshortProp &= 5; + s.UshortField &= 5; + s.UshortProp &= 5; + customClassField.UshortField &= 5; + customClassField.UshortProp &= 5; + otherCustomStructField.UshortField &= 5; + otherCustomStructField.UshortProp &= 5; + CustomClassProp.UshortField &= 5; + CustomClassProp.UshortProp &= 5; + GetClass().UshortField &= 5; + GetClass().UshortProp &= 5; +#if CS70 + GetStruct().UshortField &= 5; + GetStruct().UshortProp &= 5; + GetRefUshort() &= 5; +#endif + } + + public static void UshortBitOrTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p |= 5; + //l |= 5; + ushortField |= 5; + UshortProp |= 5; + c.UshortField |= 5; + c.UshortProp |= 5; + s.UshortField |= 5; + s.UshortProp |= 5; + customClassField.UshortField |= 5; + customClassField.UshortProp |= 5; + otherCustomStructField.UshortField |= 5; + otherCustomStructField.UshortProp |= 5; + CustomClassProp.UshortField |= 5; + CustomClassProp.UshortProp |= 5; + GetClass().UshortField |= 5; + GetClass().UshortProp |= 5; +#if CS70 + GetStruct().UshortField |= 5; + GetStruct().UshortProp |= 5; + GetRefUshort() |= 5; +#endif + } + + public static void UshortBitXorTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //p ^= 5; + //l ^= 5; + ushortField ^= 5; + UshortProp ^= 5; + c.UshortField ^= 5; + c.UshortProp ^= 5; + s.UshortField ^= 5; + s.UshortProp ^= 5; + customClassField.UshortField ^= 5; + customClassField.UshortProp ^= 5; + otherCustomStructField.UshortField ^= 5; + otherCustomStructField.UshortProp ^= 5; + CustomClassProp.UshortField ^= 5; + CustomClassProp.UshortProp ^= 5; + GetClass().UshortField ^= 5; + GetClass().UshortProp ^= 5; +#if CS70 + GetStruct().UshortField ^= 5; + GetStruct().UshortProp ^= 5; + GetRefUshort() ^= 5; +#endif + } + + public static void UshortPostIncTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //X(p++); + //X(l++); + X(ushortField++); + X(UshortProp++); + X(c.UshortField++); + X(c.UshortProp++); + X(s.UshortField++); + X(s.UshortProp++); + X(customClassField.UshortField++); + X(customClassField.UshortProp++); + X(otherCustomStructField.UshortField++); + X(otherCustomStructField.UshortProp++); + X(CustomClassProp.UshortField++); + X(CustomClassProp.UshortProp++); + X(GetClass().UshortField++); + X(GetClass().UshortProp++); +#if CS70 + X(GetStruct().UshortField++); + X(GetStruct().UshortProp++); + X(GetRefUshort()++); +#endif + } + + public static void UshortPreIncTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //X(++p); + //X(++l); + X(++ushortField); + X(++UshortProp); + X(++c.UshortField); + X(++c.UshortProp); + X(++s.UshortField); + X(++s.UshortProp); + X(++customClassField.UshortField); + X(++customClassField.UshortProp); + X(++otherCustomStructField.UshortField); + X(++otherCustomStructField.UshortProp); + X(++CustomClassProp.UshortField); + X(++CustomClassProp.UshortProp); + X(++GetClass().UshortField); + X(++GetClass().UshortProp); +#if CS70 + X(++GetStruct().UshortField); + X(++GetStruct().UshortProp); + X(++GetRefUshort()); +#endif + } + public static void UshortPostDecTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //X(p--); + //X(l--); + X(ushortField--); + X(UshortProp--); + X(c.UshortField--); + X(c.UshortProp--); + X(s.UshortField--); + X(s.UshortProp--); + X(customClassField.UshortField--); + X(customClassField.UshortProp--); + X(otherCustomStructField.UshortField--); + X(otherCustomStructField.UshortProp--); + X(CustomClassProp.UshortField--); + X(CustomClassProp.UshortProp--); + X(GetClass().UshortField--); + X(GetClass().UshortProp--); +#if CS70 + X(GetStruct().UshortField--); + X(GetStruct().UshortProp--); + X(GetRefUshort()--); +#endif + } + + public static void UshortPreDecTest(ushort p, CustomClass c, CustomStruct2 s) + { + //ushort l = 0; + //X(--p); + //X(--l); + X(--ushortField); + X(--UshortProp); + X(--c.UshortField); + X(--c.UshortProp); + X(--s.UshortField); + X(--s.UshortProp); + X(--customClassField.UshortField); + X(--customClassField.UshortProp); + X(--otherCustomStructField.UshortField); + X(--otherCustomStructField.UshortProp); + X(--CustomClassProp.UshortField); + X(--CustomClassProp.UshortProp); + X(--GetClass().UshortField); + X(--GetClass().UshortProp); +#if CS70 + X(--GetStruct().UshortField); + X(--GetStruct().UshortProp); + X(--GetRefUshort()); +#endif + } + public static void IntAddTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p += 5; + //l += 5; + intField += 5; + IntProp += 5; + c.IntField += 5; + c.IntProp += 5; + s.IntField += 5; + s.IntProp += 5; + customClassField.IntField += 5; + customClassField.IntProp += 5; + otherCustomStructField.IntField += 5; + otherCustomStructField.IntProp += 5; + CustomClassProp.IntField += 5; + CustomClassProp.IntProp += 5; + GetClass().IntField += 5; + GetClass().IntProp += 5; +#if CS70 + GetStruct().IntField += 5; + GetStruct().IntProp += 5; + GetRefInt() += 5; +#endif + } + + public static void IntSubtractTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p -= 5; + //l -= 5; + intField -= 5; + IntProp -= 5; + c.IntField -= 5; + c.IntProp -= 5; + s.IntField -= 5; + s.IntProp -= 5; + customClassField.IntField -= 5; + customClassField.IntProp -= 5; + otherCustomStructField.IntField -= 5; + otherCustomStructField.IntProp -= 5; + CustomClassProp.IntField -= 5; + CustomClassProp.IntProp -= 5; + GetClass().IntField -= 5; + GetClass().IntProp -= 5; +#if CS70 + GetStruct().IntField -= 5; + GetStruct().IntProp -= 5; + GetRefInt() -= 5; +#endif + } + + public static void IntMultiplyTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p *= 5; + //l *= 5; + intField *= 5; + IntProp *= 5; + c.IntField *= 5; + c.IntProp *= 5; + s.IntField *= 5; + s.IntProp *= 5; + customClassField.IntField *= 5; + customClassField.IntProp *= 5; + otherCustomStructField.IntField *= 5; + otherCustomStructField.IntProp *= 5; + CustomClassProp.IntField *= 5; + CustomClassProp.IntProp *= 5; + GetClass().IntField *= 5; + GetClass().IntProp *= 5; +#if CS70 + GetStruct().IntField *= 5; + GetStruct().IntProp *= 5; + GetRefInt() *= 5; +#endif + } + + public static void IntDivideTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p /= 5; + //l /= 5; + intField /= 5; + IntProp /= 5; + c.IntField /= 5; + c.IntProp /= 5; + s.IntField /= 5; + s.IntProp /= 5; + customClassField.IntField /= 5; + customClassField.IntProp /= 5; + otherCustomStructField.IntField /= 5; + otherCustomStructField.IntProp /= 5; + CustomClassProp.IntField /= 5; + CustomClassProp.IntProp /= 5; + GetClass().IntField /= 5; + GetClass().IntProp /= 5; +#if CS70 + GetStruct().IntField /= 5; + GetStruct().IntProp /= 5; + GetRefInt() /= 5; +#endif + } + + public static void IntModulusTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p %= 5; + //l %= 5; + intField %= 5; + IntProp %= 5; + c.IntField %= 5; + c.IntProp %= 5; + s.IntField %= 5; + s.IntProp %= 5; + customClassField.IntField %= 5; + customClassField.IntProp %= 5; + otherCustomStructField.IntField %= 5; + otherCustomStructField.IntProp %= 5; + CustomClassProp.IntField %= 5; + CustomClassProp.IntProp %= 5; + GetClass().IntField %= 5; + GetClass().IntProp %= 5; +#if CS70 + GetStruct().IntField %= 5; + GetStruct().IntProp %= 5; + GetRefInt() %= 5; +#endif + } + + public static void IntLeftShiftTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p <<= 5; + //l <<= 5; + intField <<= 5; + IntProp <<= 5; + c.IntField <<= 5; + c.IntProp <<= 5; + s.IntField <<= 5; + s.IntProp <<= 5; + customClassField.IntField <<= 5; + customClassField.IntProp <<= 5; + otherCustomStructField.IntField <<= 5; + otherCustomStructField.IntProp <<= 5; + CustomClassProp.IntField <<= 5; + CustomClassProp.IntProp <<= 5; + GetClass().IntField <<= 5; + GetClass().IntProp <<= 5; +#if CS70 + GetStruct().IntField <<= 5; + GetStruct().IntProp <<= 5; + GetRefInt() <<= 5; +#endif + } + + public static void IntRightShiftTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p >>= 5; + //l >>= 5; + intField >>= 5; + IntProp >>= 5; + c.IntField >>= 5; + c.IntProp >>= 5; + s.IntField >>= 5; + s.IntProp >>= 5; + customClassField.IntField >>= 5; + customClassField.IntProp >>= 5; + otherCustomStructField.IntField >>= 5; + otherCustomStructField.IntProp >>= 5; + CustomClassProp.IntField >>= 5; + CustomClassProp.IntProp >>= 5; + GetClass().IntField >>= 5; + GetClass().IntProp >>= 5; +#if CS70 + GetStruct().IntField >>= 5; + GetStruct().IntProp >>= 5; + GetRefInt() >>= 5; +#endif + } + + public static void IntBitAndTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p &= 5; + //l &= 5; + intField &= 5; + IntProp &= 5; + c.IntField &= 5; + c.IntProp &= 5; + s.IntField &= 5; + s.IntProp &= 5; + customClassField.IntField &= 5; + customClassField.IntProp &= 5; + otherCustomStructField.IntField &= 5; + otherCustomStructField.IntProp &= 5; + CustomClassProp.IntField &= 5; + CustomClassProp.IntProp &= 5; + GetClass().IntField &= 5; + GetClass().IntProp &= 5; +#if CS70 + GetStruct().IntField &= 5; + GetStruct().IntProp &= 5; + GetRefInt() &= 5; +#endif + } + + public static void IntBitOrTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p |= 5; + //l |= 5; + intField |= 5; + IntProp |= 5; + c.IntField |= 5; + c.IntProp |= 5; + s.IntField |= 5; + s.IntProp |= 5; + customClassField.IntField |= 5; + customClassField.IntProp |= 5; + otherCustomStructField.IntField |= 5; + otherCustomStructField.IntProp |= 5; + CustomClassProp.IntField |= 5; + CustomClassProp.IntProp |= 5; + GetClass().IntField |= 5; + GetClass().IntProp |= 5; +#if CS70 + GetStruct().IntField |= 5; + GetStruct().IntProp |= 5; + GetRefInt() |= 5; +#endif + } + + public static void IntBitXorTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //p ^= 5; + //l ^= 5; + intField ^= 5; + IntProp ^= 5; + c.IntField ^= 5; + c.IntProp ^= 5; + s.IntField ^= 5; + s.IntProp ^= 5; + customClassField.IntField ^= 5; + customClassField.IntProp ^= 5; + otherCustomStructField.IntField ^= 5; + otherCustomStructField.IntProp ^= 5; + CustomClassProp.IntField ^= 5; + CustomClassProp.IntProp ^= 5; + GetClass().IntField ^= 5; + GetClass().IntProp ^= 5; +#if CS70 + GetStruct().IntField ^= 5; + GetStruct().IntProp ^= 5; + GetRefInt() ^= 5; +#endif + } + + public static void IntPostIncTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //X(p++); + //X(l++); + X(intField++); + X(IntProp++); + X(c.IntField++); + X(c.IntProp++); + X(s.IntField++); + X(s.IntProp++); + X(customClassField.IntField++); + X(customClassField.IntProp++); + X(otherCustomStructField.IntField++); + X(otherCustomStructField.IntProp++); + X(CustomClassProp.IntField++); + X(CustomClassProp.IntProp++); + X(GetClass().IntField++); + X(GetClass().IntProp++); +#if CS70 + X(GetStruct().IntField++); + X(GetStruct().IntProp++); + X(GetRefInt()++); +#endif + } + + public static void IntPreIncTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //X(++p); + //X(++l); + X(++intField); + X(++IntProp); + X(++c.IntField); + X(++c.IntProp); + X(++s.IntField); + X(++s.IntProp); + X(++customClassField.IntField); + X(++customClassField.IntProp); + X(++otherCustomStructField.IntField); + X(++otherCustomStructField.IntProp); + X(++CustomClassProp.IntField); + X(++CustomClassProp.IntProp); + X(++GetClass().IntField); + X(++GetClass().IntProp); +#if CS70 + X(++GetStruct().IntField); + X(++GetStruct().IntProp); + X(++GetRefInt()); +#endif + } + public static void IntPostDecTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //X(p--); + //X(l--); + X(intField--); + X(IntProp--); + X(c.IntField--); + X(c.IntProp--); + X(s.IntField--); + X(s.IntProp--); + X(customClassField.IntField--); + X(customClassField.IntProp--); + X(otherCustomStructField.IntField--); + X(otherCustomStructField.IntProp--); + X(CustomClassProp.IntField--); + X(CustomClassProp.IntProp--); + X(GetClass().IntField--); + X(GetClass().IntProp--); +#if CS70 + X(GetStruct().IntField--); + X(GetStruct().IntProp--); + X(GetRefInt()--); +#endif + } + + public static void IntPreDecTest(int p, CustomClass c, CustomStruct2 s) + { + //int l = 0; + //X(--p); + //X(--l); + X(--intField); + X(--IntProp); + X(--c.IntField); + X(--c.IntProp); + X(--s.IntField); + X(--s.IntProp); + X(--customClassField.IntField); + X(--customClassField.IntProp); + X(--otherCustomStructField.IntField); + X(--otherCustomStructField.IntProp); + X(--CustomClassProp.IntField); + X(--CustomClassProp.IntProp); + X(--GetClass().IntField); + X(--GetClass().IntProp); +#if CS70 + X(--GetStruct().IntField); + X(--GetStruct().IntProp); + X(--GetRefInt()); +#endif + } + public static void UintAddTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p += 5u; + //l += 5u; + uintField += 5u; + UintProp += 5u; + c.UintField += 5u; + c.UintProp += 5u; + s.UintField += 5u; + s.UintProp += 5u; + customClassField.UintField += 5u; + customClassField.UintProp += 5u; + otherCustomStructField.UintField += 5u; + otherCustomStructField.UintProp += 5u; + CustomClassProp.UintField += 5u; + CustomClassProp.UintProp += 5u; + GetClass().UintField += 5u; + GetClass().UintProp += 5u; +#if CS70 + GetStruct().UintField += 5u; + GetStruct().UintProp += 5u; + GetRefUint() += 5u; +#endif + } + + public static void UintSubtractTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p -= 5u; + //l -= 5u; + uintField -= 5u; + UintProp -= 5u; + c.UintField -= 5u; + c.UintProp -= 5u; + s.UintField -= 5u; + s.UintProp -= 5u; + customClassField.UintField -= 5u; + customClassField.UintProp -= 5u; + otherCustomStructField.UintField -= 5u; + otherCustomStructField.UintProp -= 5u; + CustomClassProp.UintField -= 5u; + CustomClassProp.UintProp -= 5u; + GetClass().UintField -= 5u; + GetClass().UintProp -= 5u; +#if CS70 + GetStruct().UintField -= 5u; + GetStruct().UintProp -= 5u; + GetRefUint() -= 5u; +#endif + } + + public static void UintMultiplyTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p *= 5u; + //l *= 5u; + uintField *= 5u; + UintProp *= 5u; + c.UintField *= 5u; + c.UintProp *= 5u; + s.UintField *= 5u; + s.UintProp *= 5u; + customClassField.UintField *= 5u; + customClassField.UintProp *= 5u; + otherCustomStructField.UintField *= 5u; + otherCustomStructField.UintProp *= 5u; + CustomClassProp.UintField *= 5u; + CustomClassProp.UintProp *= 5u; + GetClass().UintField *= 5u; + GetClass().UintProp *= 5u; +#if CS70 + GetStruct().UintField *= 5u; + GetStruct().UintProp *= 5u; + GetRefUint() *= 5u; +#endif + } + + public static void UintDivideTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p /= 5u; + //l /= 5u; + uintField /= 5u; + UintProp /= 5u; + c.UintField /= 5u; + c.UintProp /= 5u; + s.UintField /= 5u; + s.UintProp /= 5u; + customClassField.UintField /= 5u; + customClassField.UintProp /= 5u; + otherCustomStructField.UintField /= 5u; + otherCustomStructField.UintProp /= 5u; + CustomClassProp.UintField /= 5u; + CustomClassProp.UintProp /= 5u; + GetClass().UintField /= 5u; + GetClass().UintProp /= 5u; +#if CS70 + GetStruct().UintField /= 5u; + GetStruct().UintProp /= 5u; + GetRefUint() /= 5u; +#endif + } + + public static void UintModulusTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p %= 5u; + //l %= 5u; + uintField %= 5u; + UintProp %= 5u; + c.UintField %= 5u; + c.UintProp %= 5u; + s.UintField %= 5u; + s.UintProp %= 5u; + customClassField.UintField %= 5u; + customClassField.UintProp %= 5u; + otherCustomStructField.UintField %= 5u; + otherCustomStructField.UintProp %= 5u; + CustomClassProp.UintField %= 5u; + CustomClassProp.UintProp %= 5u; + GetClass().UintField %= 5u; + GetClass().UintProp %= 5u; +#if CS70 + GetStruct().UintField %= 5u; + GetStruct().UintProp %= 5u; + GetRefUint() %= 5u; +#endif + } + + public static void UintLeftShiftTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p <<= 5; + //l <<= 5; + uintField <<= 5; + UintProp <<= 5; + c.UintField <<= 5; + c.UintProp <<= 5; + s.UintField <<= 5; + s.UintProp <<= 5; + customClassField.UintField <<= 5; + customClassField.UintProp <<= 5; + otherCustomStructField.UintField <<= 5; + otherCustomStructField.UintProp <<= 5; + CustomClassProp.UintField <<= 5; + CustomClassProp.UintProp <<= 5; + GetClass().UintField <<= 5; + GetClass().UintProp <<= 5; +#if CS70 + GetStruct().UintField <<= 5; + GetStruct().UintProp <<= 5; + GetRefUint() <<= 5; +#endif + } + + public static void UintRightShiftTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p >>= 5; + //l >>= 5; + uintField >>= 5; + UintProp >>= 5; + c.UintField >>= 5; + c.UintProp >>= 5; + s.UintField >>= 5; + s.UintProp >>= 5; + customClassField.UintField >>= 5; + customClassField.UintProp >>= 5; + otherCustomStructField.UintField >>= 5; + otherCustomStructField.UintProp >>= 5; + CustomClassProp.UintField >>= 5; + CustomClassProp.UintProp >>= 5; + GetClass().UintField >>= 5; + GetClass().UintProp >>= 5; +#if CS70 + GetStruct().UintField >>= 5; + GetStruct().UintProp >>= 5; + GetRefUint() >>= 5; +#endif + } + + public static void UintBitAndTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p &= 5u; + //l &= 5u; + uintField &= 5u; + UintProp &= 5u; + c.UintField &= 5u; + c.UintProp &= 5u; + s.UintField &= 5u; + s.UintProp &= 5u; + customClassField.UintField &= 5u; + customClassField.UintProp &= 5u; + otherCustomStructField.UintField &= 5u; + otherCustomStructField.UintProp &= 5u; + CustomClassProp.UintField &= 5u; + CustomClassProp.UintProp &= 5u; + GetClass().UintField &= 5u; + GetClass().UintProp &= 5u; +#if CS70 + GetStruct().UintField &= 5u; + GetStruct().UintProp &= 5u; + GetRefUint() &= 5u; +#endif + } + + public static void UintBitOrTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p |= 5u; + //l |= 5u; + uintField |= 5u; + UintProp |= 5u; + c.UintField |= 5u; + c.UintProp |= 5u; + s.UintField |= 5u; + s.UintProp |= 5u; + customClassField.UintField |= 5u; + customClassField.UintProp |= 5u; + otherCustomStructField.UintField |= 5u; + otherCustomStructField.UintProp |= 5u; + CustomClassProp.UintField |= 5u; + CustomClassProp.UintProp |= 5u; + GetClass().UintField |= 5u; + GetClass().UintProp |= 5u; +#if CS70 + GetStruct().UintField |= 5u; + GetStruct().UintProp |= 5u; + GetRefUint() |= 5u; +#endif + } + + public static void UintBitXorTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //p ^= 5u; + //l ^= 5u; + uintField ^= 5u; + UintProp ^= 5u; + c.UintField ^= 5u; + c.UintProp ^= 5u; + s.UintField ^= 5u; + s.UintProp ^= 5u; + customClassField.UintField ^= 5u; + customClassField.UintProp ^= 5u; + otherCustomStructField.UintField ^= 5u; + otherCustomStructField.UintProp ^= 5u; + CustomClassProp.UintField ^= 5u; + CustomClassProp.UintProp ^= 5u; + GetClass().UintField ^= 5u; + GetClass().UintProp ^= 5u; +#if CS70 + GetStruct().UintField ^= 5u; + GetStruct().UintProp ^= 5u; + GetRefUint() ^= 5u; +#endif + } + + public static void UintPostIncTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //X(p++); + //X(l++); + X(uintField++); + X(UintProp++); + X(c.UintField++); + X(c.UintProp++); + X(s.UintField++); + X(s.UintProp++); + X(customClassField.UintField++); + X(customClassField.UintProp++); + X(otherCustomStructField.UintField++); + X(otherCustomStructField.UintProp++); + X(CustomClassProp.UintField++); + X(CustomClassProp.UintProp++); + X(GetClass().UintField++); + X(GetClass().UintProp++); +#if CS70 + X(GetStruct().UintField++); + X(GetStruct().UintProp++); + X(GetRefUint()++); +#endif + } + + public static void UintPreIncTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //X(++p); + //X(++l); + X(++uintField); + X(++UintProp); + X(++c.UintField); + X(++c.UintProp); + X(++s.UintField); + X(++s.UintProp); + X(++customClassField.UintField); + X(++customClassField.UintProp); + X(++otherCustomStructField.UintField); + X(++otherCustomStructField.UintProp); + X(++CustomClassProp.UintField); + X(++CustomClassProp.UintProp); + X(++GetClass().UintField); + X(++GetClass().UintProp); +#if CS70 + X(++GetStruct().UintField); + X(++GetStruct().UintProp); + X(++GetRefUint()); +#endif + } + public static void UintPostDecTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //X(p--); + //X(l--); + X(uintField--); + X(UintProp--); + X(c.UintField--); + X(c.UintProp--); + X(s.UintField--); + X(s.UintProp--); + X(customClassField.UintField--); + X(customClassField.UintProp--); + X(otherCustomStructField.UintField--); + X(otherCustomStructField.UintProp--); + X(CustomClassProp.UintField--); + X(CustomClassProp.UintProp--); + X(GetClass().UintField--); + X(GetClass().UintProp--); +#if CS70 + X(GetStruct().UintField--); + X(GetStruct().UintProp--); + X(GetRefUint()--); +#endif + } + + public static void UintPreDecTest(uint p, CustomClass c, CustomStruct2 s) + { + //uint l = 0; + //X(--p); + //X(--l); + X(--uintField); + X(--UintProp); + X(--c.UintField); + X(--c.UintProp); + X(--s.UintField); + X(--s.UintProp); + X(--customClassField.UintField); + X(--customClassField.UintProp); + X(--otherCustomStructField.UintField); + X(--otherCustomStructField.UintProp); + X(--CustomClassProp.UintField); + X(--CustomClassProp.UintProp); + X(--GetClass().UintField); + X(--GetClass().UintProp); +#if CS70 + X(--GetStruct().UintField); + X(--GetStruct().UintProp); + X(--GetRefUint()); +#endif + } + public static void LongAddTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p += 5L; + //l += 5L; + longField += 5L; + LongProp += 5L; + c.LongField += 5L; + c.LongProp += 5L; + s.LongField += 5L; + s.LongProp += 5L; + customClassField.LongField += 5L; + customClassField.LongProp += 5L; + otherCustomStructField.LongField += 5L; + otherCustomStructField.LongProp += 5L; + CustomClassProp.LongField += 5L; + CustomClassProp.LongProp += 5L; + GetClass().LongField += 5L; + GetClass().LongProp += 5L; +#if CS70 + GetStruct().LongField += 5L; + GetStruct().LongProp += 5L; + GetRefLong() += 5L; +#endif + } + + public static void LongSubtractTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p -= 5L; + //l -= 5L; + longField -= 5L; + LongProp -= 5L; + c.LongField -= 5L; + c.LongProp -= 5L; + s.LongField -= 5L; + s.LongProp -= 5L; + customClassField.LongField -= 5L; + customClassField.LongProp -= 5L; + otherCustomStructField.LongField -= 5L; + otherCustomStructField.LongProp -= 5L; + CustomClassProp.LongField -= 5L; + CustomClassProp.LongProp -= 5L; + GetClass().LongField -= 5L; + GetClass().LongProp -= 5L; +#if CS70 + GetStruct().LongField -= 5L; + GetStruct().LongProp -= 5L; + GetRefLong() -= 5L; +#endif + } + + public static void LongMultiplyTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p *= 5L; + //l *= 5L; + longField *= 5L; + LongProp *= 5L; + c.LongField *= 5L; + c.LongProp *= 5L; + s.LongField *= 5L; + s.LongProp *= 5L; + customClassField.LongField *= 5L; + customClassField.LongProp *= 5L; + otherCustomStructField.LongField *= 5L; + otherCustomStructField.LongProp *= 5L; + CustomClassProp.LongField *= 5L; + CustomClassProp.LongProp *= 5L; + GetClass().LongField *= 5L; + GetClass().LongProp *= 5L; +#if CS70 + GetStruct().LongField *= 5L; + GetStruct().LongProp *= 5L; + GetRefLong() *= 5L; +#endif + } + + public static void LongDivideTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p /= 5L; + //l /= 5L; + longField /= 5L; + LongProp /= 5L; + c.LongField /= 5L; + c.LongProp /= 5L; + s.LongField /= 5L; + s.LongProp /= 5L; + customClassField.LongField /= 5L; + customClassField.LongProp /= 5L; + otherCustomStructField.LongField /= 5L; + otherCustomStructField.LongProp /= 5L; + CustomClassProp.LongField /= 5L; + CustomClassProp.LongProp /= 5L; + GetClass().LongField /= 5L; + GetClass().LongProp /= 5L; +#if CS70 + GetStruct().LongField /= 5L; + GetStruct().LongProp /= 5L; + GetRefLong() /= 5L; +#endif + } + + public static void LongModulusTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p %= 5L; + //l %= 5L; + longField %= 5L; + LongProp %= 5L; + c.LongField %= 5L; + c.LongProp %= 5L; + s.LongField %= 5L; + s.LongProp %= 5L; + customClassField.LongField %= 5L; + customClassField.LongProp %= 5L; + otherCustomStructField.LongField %= 5L; + otherCustomStructField.LongProp %= 5L; + CustomClassProp.LongField %= 5L; + CustomClassProp.LongProp %= 5L; + GetClass().LongField %= 5L; + GetClass().LongProp %= 5L; +#if CS70 + GetStruct().LongField %= 5L; + GetStruct().LongProp %= 5L; + GetRefLong() %= 5L; +#endif + } + + public static void LongLeftShiftTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p <<= 5; + //l <<= 5; + longField <<= 5; + LongProp <<= 5; + c.LongField <<= 5; + c.LongProp <<= 5; + s.LongField <<= 5; + s.LongProp <<= 5; + customClassField.LongField <<= 5; + customClassField.LongProp <<= 5; + otherCustomStructField.LongField <<= 5; + otherCustomStructField.LongProp <<= 5; + CustomClassProp.LongField <<= 5; + CustomClassProp.LongProp <<= 5; + GetClass().LongField <<= 5; + GetClass().LongProp <<= 5; +#if CS70 + GetStruct().LongField <<= 5; + GetStruct().LongProp <<= 5; + GetRefLong() <<= 5; +#endif + } + + public static void LongRightShiftTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p >>= 5; + //l >>= 5; + longField >>= 5; + LongProp >>= 5; + c.LongField >>= 5; + c.LongProp >>= 5; + s.LongField >>= 5; + s.LongProp >>= 5; + customClassField.LongField >>= 5; + customClassField.LongProp >>= 5; + otherCustomStructField.LongField >>= 5; + otherCustomStructField.LongProp >>= 5; + CustomClassProp.LongField >>= 5; + CustomClassProp.LongProp >>= 5; + GetClass().LongField >>= 5; + GetClass().LongProp >>= 5; +#if CS70 + GetStruct().LongField >>= 5; + GetStruct().LongProp >>= 5; + GetRefLong() >>= 5; +#endif + } + + public static void LongBitAndTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p &= 5L; + //l &= 5L; + longField &= 5L; + LongProp &= 5L; + c.LongField &= 5L; + c.LongProp &= 5L; + s.LongField &= 5L; + s.LongProp &= 5L; + customClassField.LongField &= 5L; + customClassField.LongProp &= 5L; + otherCustomStructField.LongField &= 5L; + otherCustomStructField.LongProp &= 5L; + CustomClassProp.LongField &= 5L; + CustomClassProp.LongProp &= 5L; + GetClass().LongField &= 5L; + GetClass().LongProp &= 5L; +#if CS70 + GetStruct().LongField &= 5L; + GetStruct().LongProp &= 5L; + GetRefLong() &= 5L; +#endif + } + + public static void LongBitOrTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p |= 5L; + //l |= 5L; + longField |= 5L; + LongProp |= 5L; + c.LongField |= 5L; + c.LongProp |= 5L; + s.LongField |= 5L; + s.LongProp |= 5L; + customClassField.LongField |= 5L; + customClassField.LongProp |= 5L; + otherCustomStructField.LongField |= 5L; + otherCustomStructField.LongProp |= 5L; + CustomClassProp.LongField |= 5L; + CustomClassProp.LongProp |= 5L; + GetClass().LongField |= 5L; + GetClass().LongProp |= 5L; +#if CS70 + GetStruct().LongField |= 5L; + GetStruct().LongProp |= 5L; + GetRefLong() |= 5L; +#endif + } + + public static void LongBitXorTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //p ^= 5L; + //l ^= 5L; + longField ^= 5L; + LongProp ^= 5L; + c.LongField ^= 5L; + c.LongProp ^= 5L; + s.LongField ^= 5L; + s.LongProp ^= 5L; + customClassField.LongField ^= 5L; + customClassField.LongProp ^= 5L; + otherCustomStructField.LongField ^= 5L; + otherCustomStructField.LongProp ^= 5L; + CustomClassProp.LongField ^= 5L; + CustomClassProp.LongProp ^= 5L; + GetClass().LongField ^= 5L; + GetClass().LongProp ^= 5L; +#if CS70 + GetStruct().LongField ^= 5L; + GetStruct().LongProp ^= 5L; + GetRefLong() ^= 5L; +#endif + } + + public static void LongPostIncTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //X(p++); + //X(l++); + X(longField++); + X(LongProp++); + X(c.LongField++); + X(c.LongProp++); + X(s.LongField++); + X(s.LongProp++); + X(customClassField.LongField++); + X(customClassField.LongProp++); + X(otherCustomStructField.LongField++); + X(otherCustomStructField.LongProp++); + X(CustomClassProp.LongField++); + X(CustomClassProp.LongProp++); + X(GetClass().LongField++); + X(GetClass().LongProp++); +#if CS70 + X(GetStruct().LongField++); + X(GetStruct().LongProp++); + X(GetRefLong()++); +#endif + } + + public static void LongPreIncTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //X(++p); + //X(++l); + X(++longField); + X(++LongProp); + X(++c.LongField); + X(++c.LongProp); + X(++s.LongField); + X(++s.LongProp); + X(++customClassField.LongField); + X(++customClassField.LongProp); + X(++otherCustomStructField.LongField); + X(++otherCustomStructField.LongProp); + X(++CustomClassProp.LongField); + X(++CustomClassProp.LongProp); + X(++GetClass().LongField); + X(++GetClass().LongProp); +#if CS70 + X(++GetStruct().LongField); + X(++GetStruct().LongProp); + X(++GetRefLong()); +#endif + } + public static void LongPostDecTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //X(p--); + //X(l--); + X(longField--); + X(LongProp--); + X(c.LongField--); + X(c.LongProp--); + X(s.LongField--); + X(s.LongProp--); + X(customClassField.LongField--); + X(customClassField.LongProp--); + X(otherCustomStructField.LongField--); + X(otherCustomStructField.LongProp--); + X(CustomClassProp.LongField--); + X(CustomClassProp.LongProp--); + X(GetClass().LongField--); + X(GetClass().LongProp--); +#if CS70 + X(GetStruct().LongField--); + X(GetStruct().LongProp--); + X(GetRefLong()--); +#endif + } + + public static void LongPreDecTest(long p, CustomClass c, CustomStruct2 s) + { + //long l = 0; + //X(--p); + //X(--l); + X(--longField); + X(--LongProp); + X(--c.LongField); + X(--c.LongProp); + X(--s.LongField); + X(--s.LongProp); + X(--customClassField.LongField); + X(--customClassField.LongProp); + X(--otherCustomStructField.LongField); + X(--otherCustomStructField.LongProp); + X(--CustomClassProp.LongField); + X(--CustomClassProp.LongProp); + X(--GetClass().LongField); + X(--GetClass().LongProp); +#if CS70 + X(--GetStruct().LongField); + X(--GetStruct().LongProp); + X(--GetRefLong()); +#endif + } + public static void UlongAddTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p += 5uL; + //l += 5uL; + ulongField += 5uL; + UlongProp += 5uL; + c.UlongField += 5uL; + c.UlongProp += 5uL; + s.UlongField += 5uL; + s.UlongProp += 5uL; + customClassField.UlongField += 5uL; + customClassField.UlongProp += 5uL; + otherCustomStructField.UlongField += 5uL; + otherCustomStructField.UlongProp += 5uL; + CustomClassProp.UlongField += 5uL; + CustomClassProp.UlongProp += 5uL; + GetClass().UlongField += 5uL; + GetClass().UlongProp += 5uL; +#if CS70 + GetStruct().UlongField += 5uL; + GetStruct().UlongProp += 5uL; + GetRefUlong() += 5uL; +#endif + } + + public static void UlongSubtractTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p -= 5uL; + //l -= 5uL; + ulongField -= 5uL; + UlongProp -= 5uL; + c.UlongField -= 5uL; + c.UlongProp -= 5uL; + s.UlongField -= 5uL; + s.UlongProp -= 5uL; + customClassField.UlongField -= 5uL; + customClassField.UlongProp -= 5uL; + otherCustomStructField.UlongField -= 5uL; + otherCustomStructField.UlongProp -= 5uL; + CustomClassProp.UlongField -= 5uL; + CustomClassProp.UlongProp -= 5uL; + GetClass().UlongField -= 5uL; + GetClass().UlongProp -= 5uL; +#if CS70 + GetStruct().UlongField -= 5uL; + GetStruct().UlongProp -= 5uL; + GetRefUlong() -= 5uL; +#endif + } + + public static void UlongMultiplyTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p *= 5uL; + //l *= 5uL; + ulongField *= 5uL; + UlongProp *= 5uL; + c.UlongField *= 5uL; + c.UlongProp *= 5uL; + s.UlongField *= 5uL; + s.UlongProp *= 5uL; + customClassField.UlongField *= 5uL; + customClassField.UlongProp *= 5uL; + otherCustomStructField.UlongField *= 5uL; + otherCustomStructField.UlongProp *= 5uL; + CustomClassProp.UlongField *= 5uL; + CustomClassProp.UlongProp *= 5uL; + GetClass().UlongField *= 5uL; + GetClass().UlongProp *= 5uL; +#if CS70 + GetStruct().UlongField *= 5uL; + GetStruct().UlongProp *= 5uL; + GetRefUlong() *= 5uL; +#endif + } + + public static void UlongDivideTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p /= 5uL; + //l /= 5uL; + ulongField /= 5uL; + UlongProp /= 5uL; + c.UlongField /= 5uL; + c.UlongProp /= 5uL; + s.UlongField /= 5uL; + s.UlongProp /= 5uL; + customClassField.UlongField /= 5uL; + customClassField.UlongProp /= 5uL; + otherCustomStructField.UlongField /= 5uL; + otherCustomStructField.UlongProp /= 5uL; + CustomClassProp.UlongField /= 5uL; + CustomClassProp.UlongProp /= 5uL; + GetClass().UlongField /= 5uL; + GetClass().UlongProp /= 5uL; +#if CS70 + GetStruct().UlongField /= 5uL; + GetStruct().UlongProp /= 5uL; + GetRefUlong() /= 5uL; +#endif + } + + public static void UlongModulusTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p %= 5uL; + //l %= 5uL; + ulongField %= 5uL; + UlongProp %= 5uL; + c.UlongField %= 5uL; + c.UlongProp %= 5uL; + s.UlongField %= 5uL; + s.UlongProp %= 5uL; + customClassField.UlongField %= 5uL; + customClassField.UlongProp %= 5uL; + otherCustomStructField.UlongField %= 5uL; + otherCustomStructField.UlongProp %= 5uL; + CustomClassProp.UlongField %= 5uL; + CustomClassProp.UlongProp %= 5uL; + GetClass().UlongField %= 5uL; + GetClass().UlongProp %= 5uL; +#if CS70 + GetStruct().UlongField %= 5uL; + GetStruct().UlongProp %= 5uL; + GetRefUlong() %= 5uL; +#endif + } + + public static void UlongLeftShiftTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p <<= 5; + //l <<= 5; + ulongField <<= 5; + UlongProp <<= 5; + c.UlongField <<= 5; + c.UlongProp <<= 5; + s.UlongField <<= 5; + s.UlongProp <<= 5; + customClassField.UlongField <<= 5; + customClassField.UlongProp <<= 5; + otherCustomStructField.UlongField <<= 5; + otherCustomStructField.UlongProp <<= 5; + CustomClassProp.UlongField <<= 5; + CustomClassProp.UlongProp <<= 5; + GetClass().UlongField <<= 5; + GetClass().UlongProp <<= 5; +#if CS70 + GetStruct().UlongField <<= 5; + GetStruct().UlongProp <<= 5; + GetRefUlong() <<= 5; +#endif + } + + public static void UlongRightShiftTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p >>= 5; + //l >>= 5; + ulongField >>= 5; + UlongProp >>= 5; + c.UlongField >>= 5; + c.UlongProp >>= 5; + s.UlongField >>= 5; + s.UlongProp >>= 5; + customClassField.UlongField >>= 5; + customClassField.UlongProp >>= 5; + otherCustomStructField.UlongField >>= 5; + otherCustomStructField.UlongProp >>= 5; + CustomClassProp.UlongField >>= 5; + CustomClassProp.UlongProp >>= 5; + GetClass().UlongField >>= 5; + GetClass().UlongProp >>= 5; +#if CS70 + GetStruct().UlongField >>= 5; + GetStruct().UlongProp >>= 5; + GetRefUlong() >>= 5; +#endif + } + + public static void UlongBitAndTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p &= 5uL; + //l &= 5uL; + ulongField &= 5uL; + UlongProp &= 5uL; + c.UlongField &= 5uL; + c.UlongProp &= 5uL; + s.UlongField &= 5uL; + s.UlongProp &= 5uL; + customClassField.UlongField &= 5uL; + customClassField.UlongProp &= 5uL; + otherCustomStructField.UlongField &= 5uL; + otherCustomStructField.UlongProp &= 5uL; + CustomClassProp.UlongField &= 5uL; + CustomClassProp.UlongProp &= 5uL; + GetClass().UlongField &= 5uL; + GetClass().UlongProp &= 5uL; +#if CS70 + GetStruct().UlongField &= 5uL; + GetStruct().UlongProp &= 5uL; + GetRefUlong() &= 5uL; +#endif + } + + public static void UlongBitOrTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p |= 5uL; + //l |= 5uL; + ulongField |= 5uL; + UlongProp |= 5uL; + c.UlongField |= 5uL; + c.UlongProp |= 5uL; + s.UlongField |= 5uL; + s.UlongProp |= 5uL; + customClassField.UlongField |= 5uL; + customClassField.UlongProp |= 5uL; + otherCustomStructField.UlongField |= 5uL; + otherCustomStructField.UlongProp |= 5uL; + CustomClassProp.UlongField |= 5uL; + CustomClassProp.UlongProp |= 5uL; + GetClass().UlongField |= 5uL; + GetClass().UlongProp |= 5uL; +#if CS70 + GetStruct().UlongField |= 5uL; + GetStruct().UlongProp |= 5uL; + GetRefUlong() |= 5uL; +#endif + } + + public static void UlongBitXorTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //p ^= 5uL; + //l ^= 5uL; + ulongField ^= 5uL; + UlongProp ^= 5uL; + c.UlongField ^= 5uL; + c.UlongProp ^= 5uL; + s.UlongField ^= 5uL; + s.UlongProp ^= 5uL; + customClassField.UlongField ^= 5uL; + customClassField.UlongProp ^= 5uL; + otherCustomStructField.UlongField ^= 5uL; + otherCustomStructField.UlongProp ^= 5uL; + CustomClassProp.UlongField ^= 5uL; + CustomClassProp.UlongProp ^= 5uL; + GetClass().UlongField ^= 5uL; + GetClass().UlongProp ^= 5uL; +#if CS70 + GetStruct().UlongField ^= 5uL; + GetStruct().UlongProp ^= 5uL; + GetRefUlong() ^= 5uL; +#endif + } + + public static void UlongPostIncTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //X(p++); + //X(l++); + X(ulongField++); + X(UlongProp++); + X(c.UlongField++); + X(c.UlongProp++); + X(s.UlongField++); + X(s.UlongProp++); + X(customClassField.UlongField++); + X(customClassField.UlongProp++); + X(otherCustomStructField.UlongField++); + X(otherCustomStructField.UlongProp++); + X(CustomClassProp.UlongField++); + X(CustomClassProp.UlongProp++); + X(GetClass().UlongField++); + X(GetClass().UlongProp++); +#if CS70 + X(GetStruct().UlongField++); + X(GetStruct().UlongProp++); + X(GetRefUlong()++); +#endif + } + + public static void UlongPreIncTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //X(++p); + //X(++l); + X(++ulongField); + X(++UlongProp); + X(++c.UlongField); + X(++c.UlongProp); + X(++s.UlongField); + X(++s.UlongProp); + X(++customClassField.UlongField); + X(++customClassField.UlongProp); + X(++otherCustomStructField.UlongField); + X(++otherCustomStructField.UlongProp); + X(++CustomClassProp.UlongField); + X(++CustomClassProp.UlongProp); + X(++GetClass().UlongField); + X(++GetClass().UlongProp); +#if CS70 + X(++GetStruct().UlongField); + X(++GetStruct().UlongProp); + X(++GetRefUlong()); +#endif + } + public static void UlongPostDecTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //X(p--); + //X(l--); + X(ulongField--); + X(UlongProp--); + X(c.UlongField--); + X(c.UlongProp--); + X(s.UlongField--); + X(s.UlongProp--); + X(customClassField.UlongField--); + X(customClassField.UlongProp--); + X(otherCustomStructField.UlongField--); + X(otherCustomStructField.UlongProp--); + X(CustomClassProp.UlongField--); + X(CustomClassProp.UlongProp--); + X(GetClass().UlongField--); + X(GetClass().UlongProp--); +#if CS70 + X(GetStruct().UlongField--); + X(GetStruct().UlongProp--); + X(GetRefUlong()--); +#endif + } + + public static void UlongPreDecTest(ulong p, CustomClass c, CustomStruct2 s) + { + //ulong l = 0; + //X(--p); + //X(--l); + X(--ulongField); + X(--UlongProp); + X(--c.UlongField); + X(--c.UlongProp); + X(--s.UlongField); + X(--s.UlongProp); + X(--customClassField.UlongField); + X(--customClassField.UlongProp); + X(--otherCustomStructField.UlongField); + X(--otherCustomStructField.UlongProp); + X(--CustomClassProp.UlongField); + X(--CustomClassProp.UlongProp); + X(--GetClass().UlongField); + X(--GetClass().UlongProp); +#if CS70 + X(--GetStruct().UlongField); + X(--GetStruct().UlongProp); + X(--GetRefUlong()); +#endif + } + public static void CustomClassAddTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p += (CustomClass)null; + //l += (CustomClass)null; + customClassField += (CustomClass)null; + CustomClassProp += (CustomClass)null; + c.CustomClassField += (CustomClass)null; + c.CustomClassProp += (CustomClass)null; + s.CustomClassField += (CustomClass)null; + s.CustomClassProp += (CustomClass)null; + customClassField.CustomClassField += (CustomClass)null; + customClassField.CustomClassProp += (CustomClass)null; + otherCustomStructField.CustomClassField += (CustomClass)null; + otherCustomStructField.CustomClassProp += (CustomClass)null; + CustomClassProp.CustomClassField += (CustomClass)null; + CustomClassProp.CustomClassProp += (CustomClass)null; + GetClass().CustomClassField += (CustomClass)null; + GetClass().CustomClassProp += (CustomClass)null; +#if CS70 + GetStruct().CustomClassField += (CustomClass)null; + GetStruct().CustomClassProp += (CustomClass)null; + GetRefCustomClass() += (CustomClass)null; +#endif + } + + public static void CustomClassSubtractTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p -= (CustomClass)null; + //l -= (CustomClass)null; + customClassField -= (CustomClass)null; + CustomClassProp -= (CustomClass)null; + c.CustomClassField -= (CustomClass)null; + c.CustomClassProp -= (CustomClass)null; + s.CustomClassField -= (CustomClass)null; + s.CustomClassProp -= (CustomClass)null; + customClassField.CustomClassField -= (CustomClass)null; + customClassField.CustomClassProp -= (CustomClass)null; + otherCustomStructField.CustomClassField -= (CustomClass)null; + otherCustomStructField.CustomClassProp -= (CustomClass)null; + CustomClassProp.CustomClassField -= (CustomClass)null; + CustomClassProp.CustomClassProp -= (CustomClass)null; + GetClass().CustomClassField -= (CustomClass)null; + GetClass().CustomClassProp -= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField -= (CustomClass)null; + GetStruct().CustomClassProp -= (CustomClass)null; + GetRefCustomClass() -= (CustomClass)null; +#endif + } + + public static void CustomClassMultiplyTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p *= (CustomClass)null; + //l *= (CustomClass)null; + customClassField *= (CustomClass)null; + CustomClassProp *= (CustomClass)null; + c.CustomClassField *= (CustomClass)null; + c.CustomClassProp *= (CustomClass)null; + s.CustomClassField *= (CustomClass)null; + s.CustomClassProp *= (CustomClass)null; + customClassField.CustomClassField *= (CustomClass)null; + customClassField.CustomClassProp *= (CustomClass)null; + otherCustomStructField.CustomClassField *= (CustomClass)null; + otherCustomStructField.CustomClassProp *= (CustomClass)null; + CustomClassProp.CustomClassField *= (CustomClass)null; + CustomClassProp.CustomClassProp *= (CustomClass)null; + GetClass().CustomClassField *= (CustomClass)null; + GetClass().CustomClassProp *= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField *= (CustomClass)null; + GetStruct().CustomClassProp *= (CustomClass)null; + GetRefCustomClass() *= (CustomClass)null; +#endif + } + + public static void CustomClassDivideTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p /= (CustomClass)null; + //l /= (CustomClass)null; + customClassField /= (CustomClass)null; + CustomClassProp /= (CustomClass)null; + c.CustomClassField /= (CustomClass)null; + c.CustomClassProp /= (CustomClass)null; + s.CustomClassField /= (CustomClass)null; + s.CustomClassProp /= (CustomClass)null; + customClassField.CustomClassField /= (CustomClass)null; + customClassField.CustomClassProp /= (CustomClass)null; + otherCustomStructField.CustomClassField /= (CustomClass)null; + otherCustomStructField.CustomClassProp /= (CustomClass)null; + CustomClassProp.CustomClassField /= (CustomClass)null; + CustomClassProp.CustomClassProp /= (CustomClass)null; + GetClass().CustomClassField /= (CustomClass)null; + GetClass().CustomClassProp /= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField /= (CustomClass)null; + GetStruct().CustomClassProp /= (CustomClass)null; + GetRefCustomClass() /= (CustomClass)null; +#endif + } + + public static void CustomClassModulusTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p %= (CustomClass)null; + //l %= (CustomClass)null; + customClassField %= (CustomClass)null; + CustomClassProp %= (CustomClass)null; + c.CustomClassField %= (CustomClass)null; + c.CustomClassProp %= (CustomClass)null; + s.CustomClassField %= (CustomClass)null; + s.CustomClassProp %= (CustomClass)null; + customClassField.CustomClassField %= (CustomClass)null; + customClassField.CustomClassProp %= (CustomClass)null; + otherCustomStructField.CustomClassField %= (CustomClass)null; + otherCustomStructField.CustomClassProp %= (CustomClass)null; + CustomClassProp.CustomClassField %= (CustomClass)null; + CustomClassProp.CustomClassProp %= (CustomClass)null; + GetClass().CustomClassField %= (CustomClass)null; + GetClass().CustomClassProp %= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField %= (CustomClass)null; + GetStruct().CustomClassProp %= (CustomClass)null; + GetRefCustomClass() %= (CustomClass)null; +#endif + } + + public static void CustomClassLeftShiftTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p <<= 5; + //l <<= 5; + customClassField <<= 5; + CustomClassProp <<= 5; + c.CustomClassField <<= 5; + c.CustomClassProp <<= 5; + s.CustomClassField <<= 5; + s.CustomClassProp <<= 5; + customClassField.CustomClassField <<= 5; + customClassField.CustomClassProp <<= 5; + otherCustomStructField.CustomClassField <<= 5; + otherCustomStructField.CustomClassProp <<= 5; + CustomClassProp.CustomClassField <<= 5; + CustomClassProp.CustomClassProp <<= 5; + GetClass().CustomClassField <<= 5; + GetClass().CustomClassProp <<= 5; +#if CS70 + GetStruct().CustomClassField <<= 5; + GetStruct().CustomClassProp <<= 5; + GetRefCustomClass() <<= 5; +#endif + } + + public static void CustomClassRightShiftTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p >>= 5; + //l >>= 5; + customClassField >>= 5; + CustomClassProp >>= 5; + c.CustomClassField >>= 5; + c.CustomClassProp >>= 5; + s.CustomClassField >>= 5; + s.CustomClassProp >>= 5; + customClassField.CustomClassField >>= 5; + customClassField.CustomClassProp >>= 5; + otherCustomStructField.CustomClassField >>= 5; + otherCustomStructField.CustomClassProp >>= 5; + CustomClassProp.CustomClassField >>= 5; + CustomClassProp.CustomClassProp >>= 5; + GetClass().CustomClassField >>= 5; + GetClass().CustomClassProp >>= 5; +#if CS70 + GetStruct().CustomClassField >>= 5; + GetStruct().CustomClassProp >>= 5; + GetRefCustomClass() >>= 5; +#endif + } + + public static void CustomClassBitAndTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p &= (CustomClass)null; + //l &= (CustomClass)null; + customClassField &= (CustomClass)null; + CustomClassProp &= (CustomClass)null; + c.CustomClassField &= (CustomClass)null; + c.CustomClassProp &= (CustomClass)null; + s.CustomClassField &= (CustomClass)null; + s.CustomClassProp &= (CustomClass)null; + customClassField.CustomClassField &= (CustomClass)null; + customClassField.CustomClassProp &= (CustomClass)null; + otherCustomStructField.CustomClassField &= (CustomClass)null; + otherCustomStructField.CustomClassProp &= (CustomClass)null; + CustomClassProp.CustomClassField &= (CustomClass)null; + CustomClassProp.CustomClassProp &= (CustomClass)null; + GetClass().CustomClassField &= (CustomClass)null; + GetClass().CustomClassProp &= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField &= (CustomClass)null; + GetStruct().CustomClassProp &= (CustomClass)null; + GetRefCustomClass() &= (CustomClass)null; +#endif + } + + public static void CustomClassBitOrTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p |= (CustomClass)null; + //l |= (CustomClass)null; + customClassField |= (CustomClass)null; + CustomClassProp |= (CustomClass)null; + c.CustomClassField |= (CustomClass)null; + c.CustomClassProp |= (CustomClass)null; + s.CustomClassField |= (CustomClass)null; + s.CustomClassProp |= (CustomClass)null; + customClassField.CustomClassField |= (CustomClass)null; + customClassField.CustomClassProp |= (CustomClass)null; + otherCustomStructField.CustomClassField |= (CustomClass)null; + otherCustomStructField.CustomClassProp |= (CustomClass)null; + CustomClassProp.CustomClassField |= (CustomClass)null; + CustomClassProp.CustomClassProp |= (CustomClass)null; + GetClass().CustomClassField |= (CustomClass)null; + GetClass().CustomClassProp |= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField |= (CustomClass)null; + GetStruct().CustomClassProp |= (CustomClass)null; + GetRefCustomClass() |= (CustomClass)null; +#endif + } + + public static void CustomClassBitXorTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //p ^= (CustomClass)null; + //l ^= (CustomClass)null; + customClassField ^= (CustomClass)null; + CustomClassProp ^= (CustomClass)null; + c.CustomClassField ^= (CustomClass)null; + c.CustomClassProp ^= (CustomClass)null; + s.CustomClassField ^= (CustomClass)null; + s.CustomClassProp ^= (CustomClass)null; + customClassField.CustomClassField ^= (CustomClass)null; + customClassField.CustomClassProp ^= (CustomClass)null; + otherCustomStructField.CustomClassField ^= (CustomClass)null; + otherCustomStructField.CustomClassProp ^= (CustomClass)null; + CustomClassProp.CustomClassField ^= (CustomClass)null; + CustomClassProp.CustomClassProp ^= (CustomClass)null; + GetClass().CustomClassField ^= (CustomClass)null; + GetClass().CustomClassProp ^= (CustomClass)null; +#if CS70 + GetStruct().CustomClassField ^= (CustomClass)null; + GetStruct().CustomClassProp ^= (CustomClass)null; + GetRefCustomClass() ^= (CustomClass)null; +#endif + } + + public static void CustomClassPostIncTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //X(p++); + //X(l++); + X(customClassField++); + X(CustomClassProp++); + X(c.CustomClassField++); + X(c.CustomClassProp++); + X(s.CustomClassField++); + X(s.CustomClassProp++); + X(customClassField.CustomClassField++); + X(customClassField.CustomClassProp++); + X(otherCustomStructField.CustomClassField++); + X(otherCustomStructField.CustomClassProp++); + X(CustomClassProp.CustomClassField++); + X(CustomClassProp.CustomClassProp++); + X(GetClass().CustomClassField++); + X(GetClass().CustomClassProp++); +#if CS70 + X(GetStruct().CustomClassField++); + X(GetStruct().CustomClassProp++); + X(GetRefCustomClass()++); +#endif + } + + public static void CustomClassPreIncTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //X(++p); + //X(++l); + X(++customClassField); + X(++CustomClassProp); + X(++c.CustomClassField); + X(++c.CustomClassProp); + X(++s.CustomClassField); + X(++s.CustomClassProp); + X(++customClassField.CustomClassField); + X(++customClassField.CustomClassProp); + X(++otherCustomStructField.CustomClassField); + X(++otherCustomStructField.CustomClassProp); + X(++CustomClassProp.CustomClassField); + X(++CustomClassProp.CustomClassProp); + X(++GetClass().CustomClassField); + X(++GetClass().CustomClassProp); +#if CS70 + X(++GetStruct().CustomClassField); + X(++GetStruct().CustomClassProp); + X(++GetRefCustomClass()); +#endif + } + public static void CustomClassPostDecTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //X(p--); + //X(l--); + X(customClassField--); + X(CustomClassProp--); + X(c.CustomClassField--); + X(c.CustomClassProp--); + X(s.CustomClassField--); + X(s.CustomClassProp--); + X(customClassField.CustomClassField--); + X(customClassField.CustomClassProp--); + X(otherCustomStructField.CustomClassField--); + X(otherCustomStructField.CustomClassProp--); + X(CustomClassProp.CustomClassField--); + X(CustomClassProp.CustomClassProp--); + X(GetClass().CustomClassField--); + X(GetClass().CustomClassProp--); +#if CS70 + X(GetStruct().CustomClassField--); + X(GetStruct().CustomClassProp--); + X(GetRefCustomClass()--); +#endif + } + + public static void CustomClassPreDecTest(CustomClass p, CustomClass c, CustomStruct2 s) + { + //CustomClass l = null; + //X(--p); + //X(--l); + X(--customClassField); + X(--CustomClassProp); + X(--c.CustomClassField); + X(--c.CustomClassProp); + X(--s.CustomClassField); + X(--s.CustomClassProp); + X(--customClassField.CustomClassField); + X(--customClassField.CustomClassProp); + X(--otherCustomStructField.CustomClassField); + X(--otherCustomStructField.CustomClassProp); + X(--CustomClassProp.CustomClassField); + X(--CustomClassProp.CustomClassProp); + X(--GetClass().CustomClassField); + X(--GetClass().CustomClassProp); +#if CS70 + X(--GetStruct().CustomClassField); + X(--GetStruct().CustomClassProp); + X(--GetRefCustomClass()); +#endif + } + public static void CustomStructAddTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p += default(CustomStruct); + //l += default(CustomStruct); + customStructField += default(CustomStruct); + CustomStructProp += default(CustomStruct); + c.CustomStructField += default(CustomStruct); + c.CustomStructProp += default(CustomStruct); + s.CustomStructField += default(CustomStruct); + s.CustomStructProp += default(CustomStruct); + customClassField.CustomStructField += default(CustomStruct); + customClassField.CustomStructProp += default(CustomStruct); + otherCustomStructField.CustomStructField += default(CustomStruct); + otherCustomStructField.CustomStructProp += default(CustomStruct); + CustomClassProp.CustomStructField += default(CustomStruct); + CustomClassProp.CustomStructProp += default(CustomStruct); + GetClass().CustomStructField += default(CustomStruct); + GetClass().CustomStructProp += default(CustomStruct); +#if CS70 + GetStruct().CustomStructField += default(CustomStruct); + GetStruct().CustomStructProp += default(CustomStruct); + GetRefCustomStruct() += default(CustomStruct); +#endif + } + + public static void CustomStructSubtractTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p -= default(CustomStruct); + //l -= default(CustomStruct); + customStructField -= default(CustomStruct); + CustomStructProp -= default(CustomStruct); + c.CustomStructField -= default(CustomStruct); + c.CustomStructProp -= default(CustomStruct); + s.CustomStructField -= default(CustomStruct); + s.CustomStructProp -= default(CustomStruct); + customClassField.CustomStructField -= default(CustomStruct); + customClassField.CustomStructProp -= default(CustomStruct); + otherCustomStructField.CustomStructField -= default(CustomStruct); + otherCustomStructField.CustomStructProp -= default(CustomStruct); + CustomClassProp.CustomStructField -= default(CustomStruct); + CustomClassProp.CustomStructProp -= default(CustomStruct); + GetClass().CustomStructField -= default(CustomStruct); + GetClass().CustomStructProp -= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField -= default(CustomStruct); + GetStruct().CustomStructProp -= default(CustomStruct); + GetRefCustomStruct() -= default(CustomStruct); +#endif + } + + public static void CustomStructMultiplyTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p *= default(CustomStruct); + //l *= default(CustomStruct); + customStructField *= default(CustomStruct); + CustomStructProp *= default(CustomStruct); + c.CustomStructField *= default(CustomStruct); + c.CustomStructProp *= default(CustomStruct); + s.CustomStructField *= default(CustomStruct); + s.CustomStructProp *= default(CustomStruct); + customClassField.CustomStructField *= default(CustomStruct); + customClassField.CustomStructProp *= default(CustomStruct); + otherCustomStructField.CustomStructField *= default(CustomStruct); + otherCustomStructField.CustomStructProp *= default(CustomStruct); + CustomClassProp.CustomStructField *= default(CustomStruct); + CustomClassProp.CustomStructProp *= default(CustomStruct); + GetClass().CustomStructField *= default(CustomStruct); + GetClass().CustomStructProp *= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField *= default(CustomStruct); + GetStruct().CustomStructProp *= default(CustomStruct); + GetRefCustomStruct() *= default(CustomStruct); +#endif + } + + public static void CustomStructDivideTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p /= default(CustomStruct); + //l /= default(CustomStruct); + customStructField /= default(CustomStruct); + CustomStructProp /= default(CustomStruct); + c.CustomStructField /= default(CustomStruct); + c.CustomStructProp /= default(CustomStruct); + s.CustomStructField /= default(CustomStruct); + s.CustomStructProp /= default(CustomStruct); + customClassField.CustomStructField /= default(CustomStruct); + customClassField.CustomStructProp /= default(CustomStruct); + otherCustomStructField.CustomStructField /= default(CustomStruct); + otherCustomStructField.CustomStructProp /= default(CustomStruct); + CustomClassProp.CustomStructField /= default(CustomStruct); + CustomClassProp.CustomStructProp /= default(CustomStruct); + GetClass().CustomStructField /= default(CustomStruct); + GetClass().CustomStructProp /= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField /= default(CustomStruct); + GetStruct().CustomStructProp /= default(CustomStruct); + GetRefCustomStruct() /= default(CustomStruct); +#endif + } + + public static void CustomStructModulusTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p %= default(CustomStruct); + //l %= default(CustomStruct); + customStructField %= default(CustomStruct); + CustomStructProp %= default(CustomStruct); + c.CustomStructField %= default(CustomStruct); + c.CustomStructProp %= default(CustomStruct); + s.CustomStructField %= default(CustomStruct); + s.CustomStructProp %= default(CustomStruct); + customClassField.CustomStructField %= default(CustomStruct); + customClassField.CustomStructProp %= default(CustomStruct); + otherCustomStructField.CustomStructField %= default(CustomStruct); + otherCustomStructField.CustomStructProp %= default(CustomStruct); + CustomClassProp.CustomStructField %= default(CustomStruct); + CustomClassProp.CustomStructProp %= default(CustomStruct); + GetClass().CustomStructField %= default(CustomStruct); + GetClass().CustomStructProp %= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField %= default(CustomStruct); + GetStruct().CustomStructProp %= default(CustomStruct); + GetRefCustomStruct() %= default(CustomStruct); +#endif + } + + public static void CustomStructLeftShiftTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p <<= 5; + //l <<= 5; + customStructField <<= 5; + CustomStructProp <<= 5; + c.CustomStructField <<= 5; + c.CustomStructProp <<= 5; + s.CustomStructField <<= 5; + s.CustomStructProp <<= 5; + customClassField.CustomStructField <<= 5; + customClassField.CustomStructProp <<= 5; + otherCustomStructField.CustomStructField <<= 5; + otherCustomStructField.CustomStructProp <<= 5; + CustomClassProp.CustomStructField <<= 5; + CustomClassProp.CustomStructProp <<= 5; + GetClass().CustomStructField <<= 5; + GetClass().CustomStructProp <<= 5; +#if CS70 + GetStruct().CustomStructField <<= 5; + GetStruct().CustomStructProp <<= 5; + GetRefCustomStruct() <<= 5; +#endif + } + + public static void CustomStructRightShiftTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p >>= 5; + //l >>= 5; + customStructField >>= 5; + CustomStructProp >>= 5; + c.CustomStructField >>= 5; + c.CustomStructProp >>= 5; + s.CustomStructField >>= 5; + s.CustomStructProp >>= 5; + customClassField.CustomStructField >>= 5; + customClassField.CustomStructProp >>= 5; + otherCustomStructField.CustomStructField >>= 5; + otherCustomStructField.CustomStructProp >>= 5; + CustomClassProp.CustomStructField >>= 5; + CustomClassProp.CustomStructProp >>= 5; + GetClass().CustomStructField >>= 5; + GetClass().CustomStructProp >>= 5; +#if CS70 + GetStruct().CustomStructField >>= 5; + GetStruct().CustomStructProp >>= 5; + GetRefCustomStruct() >>= 5; +#endif + } + + public static void CustomStructBitAndTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p &= default(CustomStruct); + //l &= default(CustomStruct); + customStructField &= default(CustomStruct); + CustomStructProp &= default(CustomStruct); + c.CustomStructField &= default(CustomStruct); + c.CustomStructProp &= default(CustomStruct); + s.CustomStructField &= default(CustomStruct); + s.CustomStructProp &= default(CustomStruct); + customClassField.CustomStructField &= default(CustomStruct); + customClassField.CustomStructProp &= default(CustomStruct); + otherCustomStructField.CustomStructField &= default(CustomStruct); + otherCustomStructField.CustomStructProp &= default(CustomStruct); + CustomClassProp.CustomStructField &= default(CustomStruct); + CustomClassProp.CustomStructProp &= default(CustomStruct); + GetClass().CustomStructField &= default(CustomStruct); + GetClass().CustomStructProp &= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField &= default(CustomStruct); + GetStruct().CustomStructProp &= default(CustomStruct); + GetRefCustomStruct() &= default(CustomStruct); +#endif + } + + public static void CustomStructBitOrTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p |= default(CustomStruct); + //l |= default(CustomStruct); + customStructField |= default(CustomStruct); + CustomStructProp |= default(CustomStruct); + c.CustomStructField |= default(CustomStruct); + c.CustomStructProp |= default(CustomStruct); + s.CustomStructField |= default(CustomStruct); + s.CustomStructProp |= default(CustomStruct); + customClassField.CustomStructField |= default(CustomStruct); + customClassField.CustomStructProp |= default(CustomStruct); + otherCustomStructField.CustomStructField |= default(CustomStruct); + otherCustomStructField.CustomStructProp |= default(CustomStruct); + CustomClassProp.CustomStructField |= default(CustomStruct); + CustomClassProp.CustomStructProp |= default(CustomStruct); + GetClass().CustomStructField |= default(CustomStruct); + GetClass().CustomStructProp |= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField |= default(CustomStruct); + GetStruct().CustomStructProp |= default(CustomStruct); + GetRefCustomStruct() |= default(CustomStruct); +#endif + } + + public static void CustomStructBitXorTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //p ^= default(CustomStruct); + //l ^= default(CustomStruct); + customStructField ^= default(CustomStruct); + CustomStructProp ^= default(CustomStruct); + c.CustomStructField ^= default(CustomStruct); + c.CustomStructProp ^= default(CustomStruct); + s.CustomStructField ^= default(CustomStruct); + s.CustomStructProp ^= default(CustomStruct); + customClassField.CustomStructField ^= default(CustomStruct); + customClassField.CustomStructProp ^= default(CustomStruct); + otherCustomStructField.CustomStructField ^= default(CustomStruct); + otherCustomStructField.CustomStructProp ^= default(CustomStruct); + CustomClassProp.CustomStructField ^= default(CustomStruct); + CustomClassProp.CustomStructProp ^= default(CustomStruct); + GetClass().CustomStructField ^= default(CustomStruct); + GetClass().CustomStructProp ^= default(CustomStruct); +#if CS70 + GetStruct().CustomStructField ^= default(CustomStruct); + GetStruct().CustomStructProp ^= default(CustomStruct); + GetRefCustomStruct() ^= default(CustomStruct); +#endif + } + + public static void CustomStructPostIncTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //X(p++); + //X(l++); + X(customStructField++); + X(CustomStructProp++); + X(c.CustomStructField++); + X(c.CustomStructProp++); + X(s.CustomStructField++); + X(s.CustomStructProp++); + X(customClassField.CustomStructField++); + X(customClassField.CustomStructProp++); + X(otherCustomStructField.CustomStructField++); + X(otherCustomStructField.CustomStructProp++); + X(CustomClassProp.CustomStructField++); + X(CustomClassProp.CustomStructProp++); + X(GetClass().CustomStructField++); + X(GetClass().CustomStructProp++); +#if CS70 + X(GetStruct().CustomStructField++); + X(GetStruct().CustomStructProp++); + X(GetRefCustomStruct()++); +#endif + } + + public static void CustomStructPreIncTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //X(++p); + //X(++l); + X(++customStructField); + X(++CustomStructProp); + X(++c.CustomStructField); + X(++c.CustomStructProp); + X(++s.CustomStructField); + X(++s.CustomStructProp); + X(++customClassField.CustomStructField); + X(++customClassField.CustomStructProp); + X(++otherCustomStructField.CustomStructField); + X(++otherCustomStructField.CustomStructProp); + X(++CustomClassProp.CustomStructField); + X(++CustomClassProp.CustomStructProp); + X(++GetClass().CustomStructField); + X(++GetClass().CustomStructProp); +#if CS70 + X(++GetStruct().CustomStructField); + X(++GetStruct().CustomStructProp); + X(++GetRefCustomStruct()); +#endif + } + public static void CustomStructPostDecTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //X(p--); + //X(l--); + X(customStructField--); + X(CustomStructProp--); + X(c.CustomStructField--); + X(c.CustomStructProp--); + X(s.CustomStructField--); + X(s.CustomStructProp--); + X(customClassField.CustomStructField--); + X(customClassField.CustomStructProp--); + X(otherCustomStructField.CustomStructField--); + X(otherCustomStructField.CustomStructProp--); + X(CustomClassProp.CustomStructField--); + X(CustomClassProp.CustomStructProp--); + X(GetClass().CustomStructField--); + X(GetClass().CustomStructProp--); +#if CS70 + X(GetStruct().CustomStructField--); + X(GetStruct().CustomStructProp--); + X(GetRefCustomStruct()--); +#endif + } + + public static void CustomStructPreDecTest(CustomStruct p, CustomClass c, CustomStruct2 s) + { + //CustomStruct l = default(CustomStruct); + //X(--p); + //X(--l); + X(--customStructField); + X(--CustomStructProp); + X(--c.CustomStructField); + X(--c.CustomStructProp); + X(--s.CustomStructField); + X(--s.CustomStructProp); + X(--customClassField.CustomStructField); + X(--customClassField.CustomStructProp); + X(--otherCustomStructField.CustomStructField); + X(--otherCustomStructField.CustomStructProp); + X(--CustomClassProp.CustomStructField); + X(--CustomClassProp.CustomStructProp); + X(--GetClass().CustomStructField); + X(--GetClass().CustomStructProp); +#if CS70 + X(--GetStruct().CustomStructField); + X(--GetStruct().CustomStructProp); + X(--GetRefCustomStruct()); +#endif + } + #endregion + + public static void AddOneToCustomClass(ref CustomClass c) + { + // This should not be turned into post-increment: + c += 1; + c.CustomClassProp += 1; + } + private static Item GetItem(object obj) { return null; diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.il index 9e4c93c88..c46bb42cb 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '2caluqpm' +.assembly CompoundAssignmentTest { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '2caluqpm.dll' -// MVID: {7839A86C-BE29-4CFE-BC36-763505CDFB63} +.module CompoundAssignmentTest.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03060000 // =============== CLASS MEMBERS DECLARATION =================== @@ -167,8 +163,8 @@ .property instance int32 Property() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() } // end of property MutableClass::Property .property instance uint8 ByteProperty() { @@ -199,1711 +195,21200 @@ } // end of class Item - .field private int32 test1 - .field private int32[] array1 - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField - .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict - .field private uint16 ushortField - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField - .field public static int32 StaticField - .field public static int16 StaticShortField - .field private static int32 'k__BackingField' - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .method public hidebysig specialname static - int32 get_StaticProperty() cil managed + .class auto ansi nested public beforefieldinit CustomClass + extends [mscorlib]System.Object { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field private uint8 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 10 (0xa) - .maxstack 1 - .locals init (int32 V_0) - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: stloc.0 - IL_0006: br.s IL_0008 - - IL_0008: ldloc.0 - IL_0009: ret - } // end of method CompoundAssignmentTest::get_StaticProperty - - .method public hidebysig specialname static - void set_StaticProperty(int32 'value') cil managed - { + .field private int8 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticProperty - - .method public hidebysig specialname static - valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - get_StaticShortProperty() cil managed - { + .field private int16 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 10 (0xa) - .maxstack 1 - .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) - IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: stloc.0 - IL_0006: br.s IL_0008 - - IL_0008: ldloc.0 - IL_0009: ret - } // end of method CompoundAssignmentTest::get_StaticShortProperty - - .method public hidebysig specialname static - void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed - { + .field private uint16 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticShortProperty + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 - .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass - M() cil managed - { - // Code size 11 (0xb) - .maxstack 1 - .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass V_0) - IL_0000: nop - IL_0001: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() - IL_0006: stloc.0 - IL_0007: br.s IL_0009 + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_ByteProp - IL_0009: ldloc.0 - IL_000a: ret - } // end of method CompoundAssignmentTest::M + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ByteProp - .method private hidebysig instance int32[0...,0...] - Array() cil managed - { - // Code size 7 (0x7) - .maxstack 1 - .locals init (int32[0...,0...] V_0) - IL_0000: nop - IL_0001: ldnull - IL_0002: stloc.0 - IL_0003: br.s IL_0005 + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 - IL_0005: ldloc.0 - IL_0006: ret - } // end of method CompoundAssignmentTest::Array + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_SbyteProp - .method private hidebysig instance int32* - GetPointer() cil managed - { - // Code size 8 (0x8) - .maxstack 1 - .locals init (int32* V_0) - IL_0000: nop - IL_0001: ldc.i4.0 - IL_0002: conv.u - IL_0003: stloc.0 - IL_0004: br.s IL_0006 + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_SbyteProp - IL_0006: ldloc.0 - IL_0007: ret - } // end of method CompoundAssignmentTest::GetPointer + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 - .method public hidebysig instance int32 - GetIndex() cil managed - { - // Code size 19 (0x13) - .maxstack 3 - .locals init (int32 V_0) - IL_0000: nop - IL_0001: newobj instance void [mscorlib]System.Random::.ctor() - IL_0006: ldc.i4.0 - IL_0007: ldc.i4.s 100 - IL_0009: callvirt instance int32 [mscorlib]System.Random::Next(int32, - int32) - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_ShortProp - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::GetIndex + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ShortProp - .method public hidebysig instance int32[] - GetArray() cil managed - { - // Code size 7 (0x7) - .maxstack 8 - IL_0000: nop - IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0006: throw - } // end of method CompoundAssignmentTest::GetArray + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 - .method public hidebysig instance int32 - GetValue(int32 'value') cil managed - { - // Code size 7 (0x7) - .maxstack 1 - .locals init (int32 V_0) - IL_0000: nop - IL_0001: ldarg.1 - IL_0002: stloc.0 - IL_0003: br.s IL_0005 + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_UshortProp - IL_0005: ldloc.0 - IL_0006: ret - } // end of method CompoundAssignmentTest::GetValue + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UshortProp - .method public hidebysig instance bool - IsUpperCaseA(char a) cil managed - { - // Code size 11 (0xb) - .maxstack 2 - .locals init (bool V_0) - IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.s 65 - IL_0004: ceq - IL_0006: stloc.0 - IL_0007: br.s IL_0009 + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 - IL_0009: ldloc.0 - IL_000a: ret - } // end of method CompoundAssignmentTest::IsUpperCaseA + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_IntProp - .method public hidebysig instance void - Int32_Local_Add(int32 i) cil managed - { - // Code size 48 (0x30) - .maxstack 8 - IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.1 - IL_0003: add + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UlongProp + + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomClass::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomStructProp + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Subtraction + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Multiply + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Division + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Modulus + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_LeftShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_RightShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_BitwiseAnd + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_BitwiseOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_ExclusiveOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Increment + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Decrement + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method CustomClass::.ctor + + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + } // end of property CustomClass::ByteProp + .property instance int8 SbyteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + } // end of property CustomClass::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + } // end of property CustomClass::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + } // end of property CustomClass::UshortProp + .property instance int32 IntProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + } // end of property CustomClass::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + } // end of property CustomClass::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + } // end of property CustomClass::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + } // end of property CustomClass::UlongProp + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + } // end of property CustomClass::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + } // end of property CustomClass::CustomStructProp + } // end of class CustomClass + + .class sequential ansi sealed nested public beforefieldinit CustomStruct + extends [mscorlib]System.ValueType + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_CustomClassProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UlongProp + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Addition + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Subtraction + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Multiply + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Division + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Modulus + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_LeftShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_RightShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_BitwiseAnd + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_BitwiseOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_ExclusiveOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Increment + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Decrement + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct::CustomClassProp + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ByteProp() + } // end of property CustomStruct::ByteProp + .property instance int8 SbyteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_SbyteProp(int8) + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_SbyteProp() + } // end of property CustomStruct::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ShortProp(int16) + } // end of property CustomStruct::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UshortProp(uint16) + } // end of property CustomStruct::UshortProp + .property instance int32 IntProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_IntProp(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_IntProp() + } // end of property CustomStruct::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UintProp(uint32) + } // end of property CustomStruct::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_LongProp() + } // end of property CustomStruct::LongProp + .property instance uint64 UlongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UlongProp(uint64) + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UlongProp() + } // end of property CustomStruct::UlongProp + } // end of class CustomStruct + + .class sequential ansi sealed nested public beforefieldinit CustomStruct2 + extends [mscorlib]System.ValueType + { + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomStructProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int8 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint16 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (int64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 11 (0xb) + .maxstack 1 + .locals init (uint64 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CustomStruct2::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UlongProp + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct2::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomStruct2::CustomStructProp + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + } // end of property CustomStruct2::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + } // end of property CustomStruct2::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + } // end of property CustomStruct2::ShortProp + .property instance uint16 UshortProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + } // end of property CustomStruct2::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + } // end of property CustomStruct2::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + } // end of property CustomStruct2::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + } // end of property CustomStruct2::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + } // end of property CustomStruct2::UlongProp + } // end of class CustomStruct2 + + .field private int32 test1 + .field private int32[] array1 + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField + .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField + .field public static int32 StaticField + .field public static int16 StaticShortField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass customClassField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct customStructField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 otherCustomStructField + .field private static uint8 byteField + .field private static int8 sbyteField + .field private static int16 shortField + .field private static uint16 ushortField + .field private static int32 intField + .field private static uint32 uintField + .field private static int64 longField + .field private static uint64 ulongField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method private hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_CustomClassProp + + .method private hidebysig specialname static + void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomClassProp + + .method private hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_CustomStructProp + + .method private hidebysig specialname static + void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomStructProp + + .method private hidebysig specialname static + uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (uint8 V_0) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_ByteProp + + .method private hidebysig specialname static + void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ByteProp + + .method private hidebysig specialname static + int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (int8 V_0) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_SbyteProp + + .method private hidebysig specialname static + void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_SbyteProp + + .method private hidebysig specialname static + int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (int16 V_0) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_ShortProp + + .method private hidebysig specialname static + void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ShortProp + + .method private hidebysig specialname static + uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (uint16 V_0) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_UshortProp + + .method private hidebysig specialname static + void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UshortProp + + .method private hidebysig specialname static + int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_IntProp + + .method private hidebysig specialname static + void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_IntProp + + .method private hidebysig specialname static + uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (uint32 V_0) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_UintProp + + .method private hidebysig specialname static + void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UintProp + + .method private hidebysig specialname static + int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (int64 V_0) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_LongProp + + .method private hidebysig specialname static + void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_LongProp + + .method private hidebysig specialname static + uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (uint64 V_0) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_UlongProp + + .method private hidebysig specialname static + void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UlongProp + + .method public hidebysig specialname static + int32 get_StaticProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_StaticProperty + + .method public hidebysig specialname static + void set_StaticProperty(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticProperty + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + get_StaticShortProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 10 (0xa) + .maxstack 1 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: stloc.0 + IL_0006: br.s IL_0008 + + IL_0008: ldloc.0 + IL_0009: ret + } // end of method CompoundAssignmentTest::get_StaticShortProperty + + .method public hidebysig specialname static + void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticShortProperty + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + GetClass() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetClass + + .method private hidebysig static void X(!!T result) cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: nop + IL_0001: ret + } // end of method CompoundAssignmentTest::X + + .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass + M() cil managed + { + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass V_0) + IL_0000: nop + IL_0001: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CompoundAssignmentTest::M + + .method private hidebysig instance int32[0...,0...] + Array() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + .locals init (int32[0...,0...] V_0) + IL_0000: nop + IL_0001: ldnull + IL_0002: stloc.0 + IL_0003: br.s IL_0005 + + IL_0005: ldloc.0 + IL_0006: ret + } // end of method CompoundAssignmentTest::Array + + .method private hidebysig instance int32* + GetPointer() cil managed + { + // Code size 8 (0x8) + .maxstack 1 + .locals init (int32* V_0) + IL_0000: nop + IL_0001: ldc.i4.0 + IL_0002: conv.u + IL_0003: stloc.0 + IL_0004: br.s IL_0006 + + IL_0006: ldloc.0 + IL_0007: ret + } // end of method CompoundAssignmentTest::GetPointer + + .method public hidebysig instance int32 + GetIndex() cil managed + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.Random::.ctor() + IL_0006: ldc.i4.0 + IL_0007: ldc.i4.s 100 + IL_0009: callvirt instance int32 [mscorlib]System.Random::Next(int32, + int32) + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::GetIndex + + .method public hidebysig instance int32[] + GetArray() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetArray + + .method public hidebysig instance int32 + GetValue(int32 'value') cil managed + { + // Code size 7 (0x7) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: stloc.0 + IL_0003: br.s IL_0005 + + IL_0005: ldloc.0 + IL_0006: ret + } // end of method CompoundAssignmentTest::GetValue + + .method public hidebysig instance bool + IsUpperCaseA(char a) cil managed + { + // Code size 11 (0xb) + .maxstack 2 + .locals init (bool V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.s 65 + IL_0004: ceq + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CompoundAssignmentTest::IsUpperCaseA + + .method public hidebysig instance void + Int32_Local_Add(int32 i) cil managed + { + // Code size 48 (0x30) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.1 + IL_0003: add + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: dup + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ldarg.1 + IL_0013: ldc.i4.1 + IL_0014: add + IL_0015: dup + IL_0016: starg.s i + IL_0018: call void [mscorlib]System.Console::WriteLine(int32) + IL_001d: nop + IL_001e: ldarg.1 + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: starg.s i + IL_0023: ldarg.1 + IL_0024: ldc.i4.5 + IL_0025: add + IL_0026: dup + IL_0027: starg.s i + IL_0029: call void [mscorlib]System.Console::WriteLine(int32) + IL_002e: nop + IL_002f: ret + } // end of method CompoundAssignmentTest::Int32_Local_Add + + .method public hidebysig instance void + Int32_Local_Sub(int32 i) cil managed + { + // Code size 48 (0x30) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.1 + IL_0003: sub + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: dup + IL_0008: ldc.i4.1 + IL_0009: sub + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ldarg.1 + IL_0013: ldc.i4.1 + IL_0014: sub + IL_0015: dup + IL_0016: starg.s i + IL_0018: call void [mscorlib]System.Console::WriteLine(int32) + IL_001d: nop + IL_001e: ldarg.1 + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: starg.s i + IL_0023: ldarg.1 + IL_0024: ldc.i4.5 + IL_0025: sub + IL_0026: dup + IL_0027: starg.s i + IL_0029: call void [mscorlib]System.Console::WriteLine(int32) + IL_002e: nop + IL_002f: ret + } // end of method CompoundAssignmentTest::Int32_Local_Sub + + .method public hidebysig instance void + Int32_Local_Mul(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: mul + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: mul + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Mul + + .method public hidebysig instance void + Int32_Local_Div(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: div + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: div + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Div + + .method public hidebysig instance void + Int32_Local_Rem(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: rem + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: rem + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Rem + + .method public hidebysig instance void + Int32_Local_BitAnd(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: and + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: and + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + + .method public hidebysig instance void + Int32_Local_BitOr(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: or + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: or + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitOr + + .method public hidebysig instance void + Int32_Local_BitXor(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: xor + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: xor + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitXor + + .method public hidebysig instance void + Int32_Local_ShiftLeft(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: shl IL_0004: starg.s i IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: shl + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + + .method public hidebysig instance void + Int32_Local_ShiftRight(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: shr + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: shr + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + + .method public hidebysig instance void + IntegerWithInline(int32 i) cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: add + IL_0004: dup + IL_0005: starg.s i + IL_0007: call void [mscorlib]System.Console::WriteLine(int32) + IL_000c: nop + IL_000d: ldarg.1 + IL_000e: call void [mscorlib]System.Console::WriteLine(int32) + IL_0013: nop + IL_0014: ret + } // end of method CompoundAssignmentTest::IntegerWithInline + + .method public hidebysig instance void + IntegerField(int32 i) cil managed + { + // Code size 72 (0x48) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0008: ldarg.1 + IL_0009: add + IL_000a: dup + IL_000b: stloc.0 + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0011: ldloc.0 + IL_0012: call void [mscorlib]System.Console::WriteLine(int32) + IL_0017: nop + IL_0018: ldarg.0 + IL_0019: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_001e: call void [mscorlib]System.Console::WriteLine(int32) + IL_0023: nop + IL_0024: ldarg.0 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_002b: ldarg.1 + IL_002c: sub + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0034: ldloc.0 + IL_0035: call void [mscorlib]System.Console::WriteLine(int32) + IL_003a: nop + IL_003b: ldarg.0 + IL_003c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0041: call void [mscorlib]System.Console::WriteLine(int32) + IL_0046: nop + IL_0047: ret + } // end of method CompoundAssignmentTest::IntegerField + + .method public hidebysig instance void + Array(int32 i) cil managed + { + // Code size 74 (0x4a) + .maxstack 4 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0007: ldarg.1 + IL_0008: ldelema [mscorlib]System.Int32 + IL_000d: dup + IL_000e: ldobj [mscorlib]System.Int32 + IL_0013: ldarg.1 + IL_0014: add + IL_0015: dup + IL_0016: stloc.0 + IL_0017: stobj [mscorlib]System.Int32 + IL_001c: ldloc.0 + IL_001d: call void [mscorlib]System.Console::WriteLine(int32) + IL_0022: nop + IL_0023: ldarg.0 + IL_0024: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0029: ldarg.1 + IL_002a: ldc.i4.2 + IL_002b: mul + IL_002c: ldelema [mscorlib]System.Int32 + IL_0031: dup + IL_0032: ldobj [mscorlib]System.Int32 + IL_0037: ldarg.1 + IL_0038: ldc.i4.2 + IL_0039: mul + IL_003a: add + IL_003b: dup + IL_003c: stloc.0 + IL_003d: stobj [mscorlib]System.Int32 + IL_0042: ldloc.0 + IL_0043: call void [mscorlib]System.Console::WriteLine(int32) + IL_0048: nop + IL_0049: ret + } // end of method CompoundAssignmentTest::Array + + .method public hidebysig instance int32 + ArrayUsageWithMethods() cil managed + { + // Code size 39 (0x27) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() + IL_0007: ldarg.0 + IL_0008: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() + IL_000d: ldelema [mscorlib]System.Int32 + IL_0012: dup + IL_0013: ldobj [mscorlib]System.Int32 + IL_0018: dup + IL_0019: stloc.1 + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: stobj [mscorlib]System.Int32 + IL_0021: ldloc.1 + IL_0022: stloc.0 + IL_0023: br.s IL_0025 + + IL_0025: ldloc.0 + IL_0026: ret + } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + + .method public hidebysig instance void + NestedField() cil managed + { + // Code size 97 (0x61) + .maxstack 3 + .locals init (bool V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0007: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex + IL_000c: ldc.i4.0 + IL_000d: ceq + IL_000f: stloc.0 + IL_0010: ldloc.0 + IL_0011: brtrue.s IL_0060 + + IL_0013: nop + IL_0014: ldarg.0 + IL_0015: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_001a: dup + IL_001b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0020: ldc.i4.2 + IL_0021: mul + IL_0022: dup + IL_0023: stloc.1 + IL_0024: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0029: ldloc.1 + IL_002a: call void [mscorlib]System.Console::WriteLine(int32) + IL_002f: nop + IL_0030: ldarg.0 + IL_0031: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_003c: ldc.i4.1 + IL_003d: add + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0043: ldarg.0 + IL_0044: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0049: dup + IL_004a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_004f: dup + IL_0050: stloc.1 + IL_0051: ldc.i4.1 + IL_0052: add + IL_0053: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0058: ldloc.1 + IL_0059: call void [mscorlib]System.Console::WriteLine(int32) + IL_005e: nop + IL_005f: nop + IL_0060: ret + } // end of method CompoundAssignmentTest::NestedField + + .method public hidebysig instance void + Enum() cil managed + { + // Code size 59 (0x3b) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: dup + IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0008: ldc.i4.2 + IL_0009: or + IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_000f: ldarg.0 + IL_0010: dup + IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0016: ldc.i4.s -5 + IL_0018: and + IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_001e: ldarg.0 + IL_001f: dup + IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0025: ldc.i4.2 + IL_0026: add + IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_002c: ldarg.0 + IL_002d: dup + IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0033: ldc.i4.3 + IL_0034: sub + IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_003a: ret + } // end of method CompoundAssignmentTest::Enum + + .method public hidebysig instance void + ShortEnumTest() cil managed + { + // Code size 62 (0x3e) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: dup + IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0008: ldc.i4.2 + IL_0009: or + IL_000a: conv.i2 + IL_000b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0010: ldarg.0 + IL_0011: dup + IL_0012: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0017: ldc.i4.4 + IL_0018: and + IL_0019: conv.i2 + IL_001a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_001f: ldarg.0 + IL_0020: dup + IL_0021: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0026: ldc.i4.2 + IL_0027: add + IL_0028: conv.i2 + IL_0029: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_002e: ldarg.0 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0035: ldc.i4.3 + IL_0036: sub + IL_0037: conv.i2 + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_003d: ret + } // end of method CompoundAssignmentTest::ShortEnumTest + + .method public hidebysig instance int32 + PreIncrementInAddition(int32 i, + int32 j) cil managed + { + // Code size 14 (0xe) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldc.i4.1 + IL_0004: add + IL_0005: dup + IL_0006: starg.s j + IL_0008: add + IL_0009: stloc.0 + IL_000a: br.s IL_000c + + IL_000c: ldloc.0 + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementInAddition + + .method public hidebysig instance int32 + PreIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int32 + IL_000e: ldc.i4.1 + IL_000f: sub + IL_0010: dup + IL_0011: stloc.1 + IL_0012: stobj [mscorlib]System.Int32 + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElement + + .method public hidebysig instance int32 + PostIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int32 + IL_000e: dup + IL_000f: stloc.1 + IL_0010: ldc.i4.1 + IL_0011: add + IL_0012: stobj [mscorlib]System.Int32 + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElement + + .method public hidebysig instance void + IncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int32 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: stobj [mscorlib]System.Int32 + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementArrayElement + + .method public hidebysig instance void + DoubleArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int32 + IL_000e: ldc.i4.2 + IL_000f: mul + IL_0010: stobj [mscorlib]System.Int32 + IL_0015: ret + } // end of method CompoundAssignmentTest::DoubleArrayElement + + .method public hidebysig instance int32 + DoubleArrayElementAndReturn(int32[] 'array', + int32 pos) cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int32 + IL_000e: ldc.i4.2 + IL_000f: mul + IL_0010: dup + IL_0011: stloc.1 + IL_0012: stobj [mscorlib]System.Int32 + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + + .method public hidebysig instance int32 + PreIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int32 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int16 + IL_000e: ldc.i4.1 + IL_000f: sub + IL_0010: conv.i2 + IL_0011: dup + IL_0012: stloc.1 + IL_0013: stobj [mscorlib]System.Int16 + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + + .method public hidebysig instance int32 + PostIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int32 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int16 + IL_000e: dup + IL_000f: stloc.1 + IL_0010: ldc.i4.1 + IL_0011: add + IL_0012: conv.i2 + IL_0013: stobj [mscorlib]System.Int16 + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + + .method public hidebysig instance void + IncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 23 (0x17) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int16 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.i2 + IL_0011: stobj [mscorlib]System.Int16 + IL_0016: ret + } // end of method CompoundAssignmentTest::IncrementArrayElementShort + + .method public hidebysig instance void + DoubleArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 23 (0x17) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int16 + IL_000e: ldc.i4.2 + IL_000f: mul + IL_0010: conv.i2 + IL_0011: stobj [mscorlib]System.Int16 + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShort + + .method public hidebysig instance int16 + DoubleArrayElementShortAndReturn(int16[] 'array', + int32 pos) cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldobj [mscorlib]System.Int16 + IL_000e: ldc.i4.2 + IL_000f: mul + IL_0010: conv.i2 + IL_0011: dup + IL_0012: stloc.1 + IL_0013: stobj [mscorlib]System.Int16 + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: dup + IL_0010: stloc.1 + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.1 + IL_0017: stloc.0 + IL_0018: br.s IL_001a + + IL_001a: ldloc.0 + IL_001b: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField + + .method public hidebysig instance int32 + PostIncrementInstanceField() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: dup + IL_000e: stloc.1 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.1 + IL_0017: stloc.0 + IL_0018: br.s IL_001a + + IL_001a: ldloc.0 + IL_001b: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField + + .method public hidebysig instance void + IncrementInstanceField() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField + + .method public hidebysig instance void + DoubleInstanceField() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleInstanceField + + .method public hidebysig instance int32 + DoubleInstanceFieldAndReturn() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: dup + IL_0010: stloc.1 + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.1 + IL_0017: stloc.0 + IL_0018: br.s IL_001a + + IL_001a: ldloc.0 + IL_001b: ret + } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: dup + IL_000b: stloc.1 + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0011: ldloc.1 + IL_0012: stloc.0 + IL_0013: br.s IL_0015 + + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + + .method public hidebysig instance int32 + PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: dup + IL_0009: stloc.1 + IL_000a: ldc.i4.1 + IL_000b: add + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0011: ldloc.1 + IL_0012: stloc.0 + IL_0013: br.s IL_0015 + + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + + .method public hidebysig instance void + IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000f: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField2 + + .method public hidebysig instance int32 + PreIncrementInstanceFieldShort() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.i2 + IL_0010: dup + IL_0011: stloc.1 + IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + + .method public hidebysig instance int32 + PostIncrementInstanceFieldShort() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: dup + IL_000e: stloc.1 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.i2 + IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + + .method public hidebysig instance void + IncrementInstanceFieldShort() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() IL_0007: dup - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ldarg.1 - IL_0013: ldc.i4.1 + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.i2 + IL_0010: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + + .method public hidebysig instance int32 + PreIncrementInstanceProperty() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: dup + IL_0010: stloc.1 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + + .method public hidebysig instance int32 + PostIncrementInstanceProperty() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: dup + IL_000e: stloc.1 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + + .method public hidebysig instance void + IncrementInstanceProperty() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0014: nop + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementInstanceProperty + + .method public hidebysig instance void + DoubleInstanceProperty() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0014: nop + IL_0015: ret + } // end of method CompoundAssignmentTest::DoubleInstanceProperty + + .method public hidebysig instance int32 + DoubleInstancePropertyAndReturn() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: dup + IL_0010: stloc.1 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.1 + IL_0018: stloc.0 + IL_0019: br.s IL_001b + + IL_001b: ldloc.0 + IL_001c: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + + .method public hidebysig instance int32 + PreIncrementInstancePropertyByte() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int32 V_0, + uint8 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.u1 + IL_0010: dup + IL_0011: stloc.1 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + + .method public hidebysig instance int32 + PostIncrementInstancePropertyByte() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int32 V_0, + uint8 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: dup + IL_000e: stloc.1 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.u1 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + + .method public hidebysig instance void + IncrementInstancePropertyByte() cil managed + { + // Code size 23 (0x17) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.u1 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0015: nop + IL_0016: ret + } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + + .method public hidebysig instance void + DoubleInstancePropertyByte() cil managed + { + // Code size 23 (0x17) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.u1 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0015: nop + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + + .method public hidebysig instance int32 + DoubleInstancePropertyByteAndReturn() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (int32 V_0, + uint8 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.u1 + IL_0010: dup + IL_0011: stloc.1 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.1 + IL_0019: stloc.0 + IL_001a: br.s IL_001c + + IL_001c: ldloc.0 + IL_001d: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticField() cil managed + { + // Code size 19 (0x13) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticField + + .method public hidebysig instance int32 + PostIncrementStaticField() cil managed + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticField + + .method public hidebysig instance void + IncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticField + + .method public hidebysig instance void + DoubleStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticField + + .method public hidebysig instance int32 + DoubleStaticFieldAndReturn() cil managed + { + // Code size 19 (0x13) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticFieldShort() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + + .method public hidebysig instance int32 + PostIncrementStaticFieldShort() cil managed + { + // Code size 20 (0x14) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + + .method public hidebysig instance void + IncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + + .method public hidebysig instance void + DoubleStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + + .method public hidebysig instance int16 + DoubleStaticFieldAndReturnShort() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + + .method public hidebysig instance int32 + PreIncrementStaticProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + + .method public hidebysig instance int32 + PostIncrementStaticProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + + .method public hidebysig instance void + IncrementStaticProperty() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: nop + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementStaticProperty + + .method public hidebysig instance void + DoubleStaticProperty() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: nop + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticProperty + + .method public hidebysig instance int32 + DoubleStaticPropertyAndReturn() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PreIncrementStaticPropertyShort() cil managed + { + // Code size 21 (0x15) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: dup + IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000f: nop + IL_0010: stloc.0 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.0 + IL_0014: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PostIncrementStaticPropertyShort() cil managed + { + // Code size 21 (0x15) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000f: nop + IL_0010: stloc.0 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.0 + IL_0014: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + + .method public hidebysig instance void + IncrementStaticPropertyShort() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: nop + IL_000f: ret + } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + + .method public hidebysig static void ByteAddTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: add + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: add + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: add + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: add + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: add + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: add + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: add + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: add + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: add + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteAddTest + + .method public hidebysig static void ByteSubtractTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: sub + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: sub + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: sub + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: sub + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: sub + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: sub + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: sub + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: sub + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: sub + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteSubtractTest + + .method public hidebysig static void ByteMultiplyTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: mul + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: mul + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: mul + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: mul + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: mul + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: mul + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: mul + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: mul + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: mul + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteMultiplyTest + + .method public hidebysig static void ByteDivideTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: div + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: div + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: div + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: div + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: div + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: div + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: div + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: div + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: div + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: div + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteDivideTest + + .method public hidebysig static void ByteModulusTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: rem + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: rem + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: rem + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: rem + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: rem + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: rem + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: rem + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: rem + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: rem + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: rem + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteModulusTest + + .method public hidebysig static void ByteLeftShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: shl + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: shl + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: shl + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: shl + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: shl + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: shl + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: shl + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: shl + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: shl + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteLeftShiftTest + + .method public hidebysig static void ByteRightShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: shr + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: shr + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: shr + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: shr + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: shr + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: shr + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: shr + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: shr + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: shr + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteRightShiftTest + + .method public hidebysig static void ByteBitAndTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: and + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: and + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: and + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: and + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: and + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: and + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: and + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: and + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: and + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteBitAndTest + + .method public hidebysig static void ByteBitOrTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: or + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: or + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: or + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: or + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: or + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: or + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: or + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: or + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: or + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteBitOrTest + + .method public hidebysig static void ByteBitXorTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0043: ldc.i4.5 + IL_0044: xor + IL_0045: conv.u1 + IL_0046: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0053: ldc.i4.5 + IL_0054: xor + IL_0055: conv.u1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0067: ldc.i4.5 + IL_0068: xor + IL_0069: conv.u1 + IL_006a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_007a: ldc.i4.5 + IL_007b: xor + IL_007c: conv.u1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008e: ldc.i4.5 + IL_008f: xor + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00a1: ldc.i4.5 + IL_00a2: xor + IL_00a3: conv.u1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b5: ldc.i4.5 + IL_00b6: xor + IL_00b7: conv.u1 + IL_00b8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c8: ldc.i4.5 + IL_00c9: xor + IL_00ca: conv.u1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: conv.u1 + IL_00df: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ef: ldc.i4.5 + IL_00f0: xor + IL_00f1: conv.u1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ByteBitXorTest + + .method public hidebysig static void BytePostIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.u1 + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.u1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.u1 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.u1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: add + IL_0067: conv.u1 + IL_0068: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: add + IL_0080: conv.u1 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: add + IL_009d: conv.u1 + IL_009e: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: add + IL_00b9: conv.u1 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: add + IL_00d6: conv.u1 + IL_00d7: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: add + IL_00f2: conv.u1 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: add + IL_010f: conv.u1 + IL_0110: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: add + IL_012b: conv.u1 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.u1 + IL_0149: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.u1 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::BytePostIncTest + + .method public hidebysig static void BytePreIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u1 + IL_0009: dup + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.u1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.u1 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.u1 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0063: ldc.i4.1 + IL_0064: add + IL_0065: conv.u1 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_007c: ldc.i4.1 + IL_007d: add + IL_007e: conv.u1 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0099: ldc.i4.1 + IL_009a: add + IL_009b: conv.u1 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b5: ldc.i4.1 + IL_00b6: add + IL_00b7: conv.u1 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.u1 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00ee: ldc.i4.1 + IL_00ef: add + IL_00f0: conv.u1 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010b: ldc.i4.1 + IL_010c: add + IL_010d: conv.u1 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0127: ldc.i4.1 + IL_0128: add + IL_0129: conv.u1 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0144: ldc.i4.1 + IL_0145: add + IL_0146: conv.u1 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0160: ldc.i4.1 + IL_0161: add + IL_0162: conv.u1 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::BytePreIncTest + + .method public hidebysig static void BytePostDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.u1 + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.u1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.u1 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.u1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: sub + IL_0067: conv.u1 + IL_0068: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: sub + IL_0080: conv.u1 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: sub + IL_009d: conv.u1 + IL_009e: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: sub + IL_00b9: conv.u1 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: sub + IL_00d6: conv.u1 + IL_00d7: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: sub + IL_00f2: conv.u1 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: sub + IL_010f: conv.u1 + IL_0110: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: sub + IL_012b: conv.u1 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.u1 + IL_0149: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.u1 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::BytePostDecTest + + .method public hidebysig static void BytePreDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: dup + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.u1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.u1 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.u1 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0063: ldc.i4.1 + IL_0064: sub + IL_0065: conv.u1 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_007c: ldc.i4.1 + IL_007d: sub + IL_007e: conv.u1 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0099: ldc.i4.1 + IL_009a: sub + IL_009b: conv.u1 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b5: ldc.i4.1 + IL_00b6: sub + IL_00b7: conv.u1 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.u1 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00ee: ldc.i4.1 + IL_00ef: sub + IL_00f0: conv.u1 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010b: ldc.i4.1 + IL_010c: sub + IL_010d: conv.u1 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0127: ldc.i4.1 + IL_0128: sub + IL_0129: conv.u1 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0144: ldc.i4.1 + IL_0145: sub + IL_0146: conv.u1 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0160: ldc.i4.1 + IL_0161: sub + IL_0162: conv.u1 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::BytePreDecTest + + .method public hidebysig static void SbyteAddTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: add + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: add + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: add + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: add + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: add + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: add + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: add + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: add + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: add + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteAddTest + + .method public hidebysig static void SbyteSubtractTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: sub + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: sub + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: sub + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: sub + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: sub + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: sub + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: sub + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: sub + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: sub + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteSubtractTest + + .method public hidebysig static void SbyteMultiplyTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: mul + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: mul + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: mul + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: mul + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: mul + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: mul + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: mul + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: mul + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: mul + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteMultiplyTest + + .method public hidebysig static void SbyteDivideTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: div + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: div + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: div + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: div + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: div + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: div + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: div + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: div + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: div + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: div + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteDivideTest + + .method public hidebysig static void SbyteModulusTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: rem + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: rem + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: rem + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: rem + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: rem + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: rem + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: rem + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: rem + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: rem + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: rem + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteModulusTest + + .method public hidebysig static void SbyteLeftShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: shl + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: shl + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: shl + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: shl + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: shl + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: shl + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: shl + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: shl + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: shl + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteLeftShiftTest + + .method public hidebysig static void SbyteRightShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: shr + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: shr + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: shr + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: shr + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: shr + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: shr + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: shr + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: shr + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: shr + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteRightShiftTest + + .method public hidebysig static void SbyteBitAndTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: and + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: and + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: and + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: and + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: and + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: and + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: and + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: and + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: and + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteBitAndTest + + .method public hidebysig static void SbyteBitOrTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: or + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: or + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: or + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: or + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: or + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: or + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: or + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: or + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: or + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteBitOrTest + + .method public hidebysig static void SbyteBitXorTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0043: ldc.i4.5 + IL_0044: xor + IL_0045: conv.i1 + IL_0046: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0053: ldc.i4.5 + IL_0054: xor + IL_0055: conv.i1 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0067: ldc.i4.5 + IL_0068: xor + IL_0069: conv.i1 + IL_006a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_007a: ldc.i4.5 + IL_007b: xor + IL_007c: conv.i1 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008e: ldc.i4.5 + IL_008f: xor + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00a1: ldc.i4.5 + IL_00a2: xor + IL_00a3: conv.i1 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b5: ldc.i4.5 + IL_00b6: xor + IL_00b7: conv.i1 + IL_00b8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c8: ldc.i4.5 + IL_00c9: xor + IL_00ca: conv.i1 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: conv.i1 + IL_00df: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ef: ldc.i4.5 + IL_00f0: xor + IL_00f1: conv.i1 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::SbyteBitXorTest + + .method public hidebysig static void SbytePostIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i1 + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.i1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.i1 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.i1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: add + IL_0067: conv.i1 + IL_0068: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: add + IL_0080: conv.i1 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: add + IL_009d: conv.i1 + IL_009e: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: add + IL_00b9: conv.i1 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: add + IL_00d6: conv.i1 + IL_00d7: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: add + IL_00f2: conv.i1 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: add + IL_010f: conv.i1 + IL_0110: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: add + IL_012b: conv.i1 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.i1 + IL_0149: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.i1 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::SbytePostIncTest + + .method public hidebysig static void SbytePreIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i1 + IL_0009: dup + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.i1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.i1 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.i1 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0063: ldc.i4.1 + IL_0064: add + IL_0065: conv.i1 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_007c: ldc.i4.1 + IL_007d: add + IL_007e: conv.i1 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0099: ldc.i4.1 + IL_009a: add + IL_009b: conv.i1 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b5: ldc.i4.1 + IL_00b6: add + IL_00b7: conv.i1 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.i1 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00ee: ldc.i4.1 + IL_00ef: add + IL_00f0: conv.i1 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010b: ldc.i4.1 + IL_010c: add + IL_010d: conv.i1 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0127: ldc.i4.1 + IL_0128: add + IL_0129: conv.i1 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0144: ldc.i4.1 + IL_0145: add + IL_0146: conv.i1 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0160: ldc.i4.1 + IL_0161: add + IL_0162: conv.i1 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::SbytePreIncTest + + .method public hidebysig static void SbytePostDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.i1 + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.i1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.i1 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.i1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: sub + IL_0067: conv.i1 + IL_0068: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: sub + IL_0080: conv.i1 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: sub + IL_009d: conv.i1 + IL_009e: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: sub + IL_00b9: conv.i1 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: sub + IL_00d6: conv.i1 + IL_00d7: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: sub + IL_00f2: conv.i1 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: sub + IL_010f: conv.i1 + IL_0110: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: sub + IL_012b: conv.i1 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.i1 + IL_0149: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.i1 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::SbytePostDecTest + + .method public hidebysig static void SbytePreDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: dup + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.i1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.i1 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.i1 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0063: ldc.i4.1 + IL_0064: sub + IL_0065: conv.i1 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_007c: ldc.i4.1 + IL_007d: sub + IL_007e: conv.i1 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0099: ldc.i4.1 + IL_009a: sub + IL_009b: conv.i1 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b5: ldc.i4.1 + IL_00b6: sub + IL_00b7: conv.i1 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.i1 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00ee: ldc.i4.1 + IL_00ef: sub + IL_00f0: conv.i1 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010b: ldc.i4.1 + IL_010c: sub + IL_010d: conv.i1 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0127: ldc.i4.1 + IL_0128: sub + IL_0129: conv.i1 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0144: ldc.i4.1 + IL_0145: sub + IL_0146: conv.i1 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0160: ldc.i4.1 + IL_0161: sub + IL_0162: conv.i1 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::SbytePreDecTest + + .method public hidebysig static void ShortAddTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 IL_0014: add - IL_0015: dup - IL_0016: starg.s i - IL_0018: call void [mscorlib]System.Console::WriteLine(int32) - IL_001d: nop - IL_001e: ldarg.1 - IL_001f: ldc.i4.5 - IL_0020: add - IL_0021: starg.s i - IL_0023: ldarg.1 - IL_0024: ldc.i4.5 - IL_0025: add - IL_0026: dup - IL_0027: starg.s i - IL_0029: call void [mscorlib]System.Console::WriteLine(int32) - IL_002e: nop - IL_002f: ret - } // end of method CompoundAssignmentTest::Int32_Local_Add + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: add + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: add + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: add + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: add + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: add + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: add + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: add + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: add + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: add + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortAddTest - .method public hidebysig instance void - Int32_Local_Sub(int32 i) cil managed + .method public hidebysig static void ShortSubtractTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 48 (0x30) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.1 - IL_0003: sub - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: dup - IL_0008: ldc.i4.1 - IL_0009: sub - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ldarg.1 - IL_0013: ldc.i4.1 + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 IL_0014: sub - IL_0015: dup - IL_0016: starg.s i - IL_0018: call void [mscorlib]System.Console::WriteLine(int32) - IL_001d: nop - IL_001e: ldarg.1 - IL_001f: ldc.i4.5 - IL_0020: sub - IL_0021: starg.s i - IL_0023: ldarg.1 - IL_0024: ldc.i4.5 - IL_0025: sub - IL_0026: dup - IL_0027: starg.s i - IL_0029: call void [mscorlib]System.Console::WriteLine(int32) - IL_002e: nop - IL_002f: ret - } // end of method CompoundAssignmentTest::Int32_Local_Sub + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: sub + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: sub + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: sub + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: sub + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: sub + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: sub + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: sub + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: sub + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: sub + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortSubtractTest - .method public hidebysig instance void - Int32_Local_Mul(int32 i) cil managed + .method public hidebysig static void ShortMultiplyTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: mul - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: mul - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Mul + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: mul + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: mul + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: mul + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: mul + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: mul + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: mul + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: mul + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: mul + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: mul + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortMultiplyTest - .method public hidebysig instance void - Int32_Local_Div(int32 i) cil managed + .method public hidebysig static void ShortDivideTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: div - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: div - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Div + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: div + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: div + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: div + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: div + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: div + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: div + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: div + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: div + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: div + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: div + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortDivideTest - .method public hidebysig instance void - Int32_Local_Rem(int32 i) cil managed + .method public hidebysig static void ShortModulusTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: rem - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: rem - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Rem + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: rem + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: rem + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: rem + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: rem + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: rem + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: rem + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: rem + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: rem + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: rem + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: rem + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortModulusTest - .method public hidebysig instance void - Int32_Local_BitAnd(int32 i) cil managed + .method public hidebysig static void ShortLeftShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: and - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: and + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: shl + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: shl + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: shl + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: shl + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: shl + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: shl + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: shl + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: shl + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: shl + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortLeftShiftTest + + .method public hidebysig static void ShortRightShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: shr + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: shr + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: shr + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: shr + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: shr + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: shr + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: shr + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: shr + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: shr + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortRightShiftTest + + .method public hidebysig static void ShortBitAndTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: and + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: and + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: and + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: and + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: and + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: and + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: and + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: and + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: and + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortBitAndTest + + .method public hidebysig static void ShortBitOrTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: or + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: or + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: or + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: or + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: or + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: or + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: or + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: or + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: or + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortBitOrTest + + .method public hidebysig static void ShortBitXorTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0043: ldc.i4.5 + IL_0044: xor + IL_0045: conv.i2 + IL_0046: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0053: ldc.i4.5 + IL_0054: xor + IL_0055: conv.i2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0067: ldc.i4.5 + IL_0068: xor + IL_0069: conv.i2 + IL_006a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_007a: ldc.i4.5 + IL_007b: xor + IL_007c: conv.i2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008e: ldc.i4.5 + IL_008f: xor + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00a1: ldc.i4.5 + IL_00a2: xor + IL_00a3: conv.i2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b5: ldc.i4.5 + IL_00b6: xor + IL_00b7: conv.i2 + IL_00b8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c8: ldc.i4.5 + IL_00c9: xor + IL_00ca: conv.i2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: conv.i2 + IL_00df: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ef: ldc.i4.5 + IL_00f0: xor + IL_00f1: conv.i2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::ShortBitXorTest + + .method public hidebysig static void ShortPostIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.i2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.i2 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.i2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: add + IL_0067: conv.i2 + IL_0068: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: add + IL_0080: conv.i2 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: add + IL_009d: conv.i2 + IL_009e: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: add + IL_00b9: conv.i2 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: add + IL_00d6: conv.i2 + IL_00d7: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: add + IL_00f2: conv.i2 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: add + IL_010f: conv.i2 + IL_0110: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: add + IL_012b: conv.i2 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.i2 + IL_0149: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.i2 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::ShortPostIncTest + + .method public hidebysig static void ShortPreIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.i2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.i2 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.i2 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0063: ldc.i4.1 + IL_0064: add + IL_0065: conv.i2 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_007c: ldc.i4.1 + IL_007d: add + IL_007e: conv.i2 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0099: ldc.i4.1 + IL_009a: add + IL_009b: conv.i2 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b5: ldc.i4.1 + IL_00b6: add + IL_00b7: conv.i2 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.i2 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00ee: ldc.i4.1 + IL_00ef: add + IL_00f0: conv.i2 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010b: ldc.i4.1 + IL_010c: add + IL_010d: conv.i2 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0127: ldc.i4.1 + IL_0128: add + IL_0129: conv.i2 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0144: ldc.i4.1 + IL_0145: add + IL_0146: conv.i2 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0160: ldc.i4.1 + IL_0161: add + IL_0162: conv.i2 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::ShortPreIncTest - .method public hidebysig instance void - Int32_Local_BitOr(int32 i) cil managed + .method public hidebysig static void ShortPostDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (int16 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: or - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: or + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.i2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.i2 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.i2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: sub + IL_0067: conv.i2 + IL_0068: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: sub + IL_0080: conv.i2 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: sub + IL_009d: conv.i2 + IL_009e: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: sub + IL_00b9: conv.i2 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: sub + IL_00d6: conv.i2 + IL_00d7: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: sub + IL_00f2: conv.i2 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: sub + IL_010f: conv.i2 + IL_0110: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: sub + IL_012b: conv.i2 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.i2 + IL_0149: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.i2 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::ShortPostDecTest + + .method public hidebysig static void ShortPreDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i2 IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitOr + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.i2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.i2 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.i2 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0063: ldc.i4.1 + IL_0064: sub + IL_0065: conv.i2 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_007c: ldc.i4.1 + IL_007d: sub + IL_007e: conv.i2 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0099: ldc.i4.1 + IL_009a: sub + IL_009b: conv.i2 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b5: ldc.i4.1 + IL_00b6: sub + IL_00b7: conv.i2 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.i2 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00ee: ldc.i4.1 + IL_00ef: sub + IL_00f0: conv.i2 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010b: ldc.i4.1 + IL_010c: sub + IL_010d: conv.i2 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0127: ldc.i4.1 + IL_0128: sub + IL_0129: conv.i2 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0144: ldc.i4.1 + IL_0145: sub + IL_0146: conv.i2 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0160: ldc.i4.1 + IL_0161: sub + IL_0162: conv.i2 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::ShortPreDecTest + + .method public hidebysig static void UshortAddTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: add + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: add + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: add + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: add + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: add + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: add + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: add + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: add + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: add + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortAddTest - .method public hidebysig instance void - Int32_Local_BitXor(int32 i) cil managed + .method public hidebysig static void UshortSubtractTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: xor - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: xor - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitXor + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: sub + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: sub + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: sub + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: sub + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: sub + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: sub + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: sub + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: sub + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: sub + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortSubtractTest - .method public hidebysig instance void - Int32_Local_ShiftLeft(int32 i) cil managed + .method public hidebysig static void UshortMultiplyTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: shl - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: shl - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: mul + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: mul + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: mul + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: mul + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: mul + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: mul + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: mul + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: mul + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: mul + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortMultiplyTest - .method public hidebysig instance void - Int32_Local_ShiftRight(int32 i) cil managed + .method public hidebysig static void UshortDivideTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: shr - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: shr - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: div + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: div + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: div + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: div + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: div + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: div + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: div + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: div + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: div + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: div + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortDivideTest - .method public hidebysig instance void - IntegerWithInline(int32 i) cil managed + .method public hidebysig static void UshortModulusTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: add - IL_0004: dup - IL_0005: starg.s i - IL_0007: call void [mscorlib]System.Console::WriteLine(int32) - IL_000c: nop - IL_000d: ldarg.1 - IL_000e: call void [mscorlib]System.Console::WriteLine(int32) - IL_0013: nop - IL_0014: ret - } // end of method CompoundAssignmentTest::IntegerWithInline + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: rem + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: rem + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: rem + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: rem + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: rem + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: rem + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: rem + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: rem + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: rem + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: rem + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortModulusTest - .method public hidebysig instance void - IntegerField(int32 i) cil managed + .method public hidebysig static void UshortLeftShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 72 (0x48) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0008: ldarg.1 - IL_0009: add - IL_000a: dup - IL_000b: stloc.0 - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0011: ldloc.0 - IL_0012: call void [mscorlib]System.Console::WriteLine(int32) - IL_0017: nop - IL_0018: ldarg.0 - IL_0019: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_001e: call void [mscorlib]System.Console::WriteLine(int32) - IL_0023: nop - IL_0024: ldarg.0 - IL_0025: dup - IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField IL_002b: ldarg.1 - IL_002c: sub - IL_002d: dup - IL_002e: stloc.0 - IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0034: ldloc.0 - IL_0035: call void [mscorlib]System.Console::WriteLine(int32) + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) IL_003a: nop - IL_003b: ldarg.0 - IL_003c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0041: call void [mscorlib]System.Console::WriteLine(int32) - IL_0046: nop - IL_0047: ret - } // end of method CompoundAssignmentTest::IntegerField + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: shl + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: shl + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: shl + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: shl + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: shl + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: shl + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: shl + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: shl + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: shl + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortLeftShiftTest - .method public hidebysig instance void - Array(int32 i) cil managed + .method public hidebysig static void UshortRightShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 74 (0x4a) - .maxstack 4 - .locals init (int32 V_0) + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0007: ldarg.1 - IL_0008: ldelema [mscorlib]System.Int32 - IL_000d: dup - IL_000e: ldobj [mscorlib]System.Int32 - IL_0013: ldarg.1 - IL_0014: add - IL_0015: dup - IL_0016: stloc.0 - IL_0017: stobj [mscorlib]System.Int32 - IL_001c: ldloc.0 - IL_001d: call void [mscorlib]System.Console::WriteLine(int32) - IL_0022: nop - IL_0023: ldarg.0 - IL_0024: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0029: ldarg.1 - IL_002a: ldc.i4.2 - IL_002b: mul - IL_002c: ldelema [mscorlib]System.Int32 - IL_0031: dup - IL_0032: ldobj [mscorlib]System.Int32 - IL_0037: ldarg.1 - IL_0038: ldc.i4.2 - IL_0039: mul - IL_003a: add - IL_003b: dup - IL_003c: stloc.0 - IL_003d: stobj [mscorlib]System.Int32 - IL_0042: ldloc.0 - IL_0043: call void [mscorlib]System.Console::WriteLine(int32) - IL_0048: nop - IL_0049: ret - } // end of method CompoundAssignmentTest::Array + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: shr + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: shr + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: shr + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: shr + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: shr + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: shr + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: shr + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: shr + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: shr + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortRightShiftTest - .method public hidebysig instance int32 - ArrayUsageWithMethods() cil managed + .method public hidebysig static void UshortBitAndTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 39 (0x27) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() - IL_0007: ldarg.0 - IL_0008: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() - IL_000d: ldelema [mscorlib]System.Int32 - IL_0012: dup - IL_0013: ldobj [mscorlib]System.Int32 - IL_0018: dup - IL_0019: stloc.1 - IL_001a: ldc.i4.1 - IL_001b: add - IL_001c: stobj [mscorlib]System.Int32 - IL_0021: ldloc.1 - IL_0022: stloc.0 - IL_0023: br.s IL_0025 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: and + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: and + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: and + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: and + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: and + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: and + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: and + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: and + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: and + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortBitAndTest - IL_0025: ldloc.0 - IL_0026: ret - } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + .method public hidebysig static void UshortBitOrTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: or + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: or + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: or + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: or + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: or + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: or + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: or + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: or + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: or + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortBitOrTest - .method public hidebysig instance void - NestedField() cil managed + .method public hidebysig static void UshortBitXorTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 97 (0x61) + // Code size 249 (0xf9) .maxstack 3 - .locals init (bool V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0007: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex - IL_000c: ldc.i4.0 - IL_000d: ceq - IL_000f: stloc.0 - IL_0010: ldloc.0 - IL_0011: brtrue.s IL_0060 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0043: ldc.i4.5 + IL_0044: xor + IL_0045: conv.u2 + IL_0046: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0053: ldc.i4.5 + IL_0054: xor + IL_0055: conv.u2 + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0067: ldc.i4.5 + IL_0068: xor + IL_0069: conv.u2 + IL_006a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_007a: ldc.i4.5 + IL_007b: xor + IL_007c: conv.u2 + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008e: ldc.i4.5 + IL_008f: xor + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00a1: ldc.i4.5 + IL_00a2: xor + IL_00a3: conv.u2 + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b5: ldc.i4.5 + IL_00b6: xor + IL_00b7: conv.u2 + IL_00b8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c8: ldc.i4.5 + IL_00c9: xor + IL_00ca: conv.u2 + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: conv.u2 + IL_00df: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ef: ldc.i4.5 + IL_00f0: xor + IL_00f1: conv.u2 + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UshortBitXorTest - IL_0013: nop - IL_0014: ldarg.0 - IL_0015: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + .method public hidebysig static void UshortPostIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.u2 + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() IL_001a: dup - IL_001b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0020: ldc.i4.2 - IL_0021: mul - IL_0022: dup - IL_0023: stloc.1 - IL_0024: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0029: ldloc.1 - IL_002a: call void [mscorlib]System.Console::WriteLine(int32) - IL_002f: nop - IL_0030: ldarg.0 - IL_0031: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0036: dup - IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_003c: ldc.i4.1 - IL_003d: add - IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0043: ldarg.0 - IL_0044: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.u2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.u2 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() IL_0049: dup - IL_004a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_004f: dup - IL_0050: stloc.1 - IL_0051: ldc.i4.1 - IL_0052: add - IL_0053: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0058: ldloc.1 - IL_0059: call void [mscorlib]System.Console::WriteLine(int32) - IL_005e: nop - IL_005f: nop - IL_0060: ret - } // end of method CompoundAssignmentTest::NestedField + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.u2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: add + IL_0067: conv.u2 + IL_0068: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: add + IL_0080: conv.u2 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: add + IL_009d: conv.u2 + IL_009e: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: add + IL_00b9: conv.u2 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: add + IL_00d6: conv.u2 + IL_00d7: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: add + IL_00f2: conv.u2 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: add + IL_010f: conv.u2 + IL_0110: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: add + IL_012b: conv.u2 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.u2 + IL_0149: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.u2 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UshortPostIncTest + + .method public hidebysig static void UshortPreIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u2 + IL_0009: dup + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.u2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.u2 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.u2 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0063: ldc.i4.1 + IL_0064: add + IL_0065: conv.u2 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_007c: ldc.i4.1 + IL_007d: add + IL_007e: conv.u2 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0099: ldc.i4.1 + IL_009a: add + IL_009b: conv.u2 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b5: ldc.i4.1 + IL_00b6: add + IL_00b7: conv.u2 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.u2 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00ee: ldc.i4.1 + IL_00ef: add + IL_00f0: conv.u2 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010b: ldc.i4.1 + IL_010c: add + IL_010d: conv.u2 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0127: ldc.i4.1 + IL_0128: add + IL_0129: conv.u2 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0144: ldc.i4.1 + IL_0145: add + IL_0146: conv.u2 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0160: ldc.i4.1 + IL_0161: add + IL_0162: conv.u2 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UshortPreIncTest - .method public hidebysig instance void - Enum() cil managed + .method public hidebysig static void UshortPostDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 59 (0x3b) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint16 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: dup - IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0008: ldc.i4.2 - IL_0009: or - IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_000f: ldarg.0 - IL_0010: dup - IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0016: ldc.i4.s -5 - IL_0018: and - IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_001e: ldarg.0 - IL_001f: dup - IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0025: ldc.i4.2 - IL_0026: add - IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_002c: ldarg.0 - IL_002d: dup - IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0033: ldc.i4.3 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.u2 + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.u2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 IL_0034: sub - IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_003a: ret - } // end of method CompoundAssignmentTest::Enum + IL_0035: conv.u2 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.u2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: sub + IL_0067: conv.u2 + IL_0068: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: sub + IL_0080: conv.u2 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: sub + IL_009d: conv.u2 + IL_009e: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: sub + IL_00b9: conv.u2 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: sub + IL_00d6: conv.u2 + IL_00d7: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: sub + IL_00f2: conv.u2 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: sub + IL_010f: conv.u2 + IL_0110: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: sub + IL_012b: conv.u2 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.u2 + IL_0149: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.u2 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UshortPostDecTest - .method public hidebysig instance void - ShortEnumTest() cil managed + .method public hidebysig static void UshortPreDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 62 (0x3e) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint16 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: dup - IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0008: ldc.i4.2 - IL_0009: or - IL_000a: conv.i2 - IL_000b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0010: ldarg.0 - IL_0011: dup - IL_0012: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0017: ldc.i4.4 - IL_0018: and - IL_0019: conv.i2 - IL_001a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_001f: ldarg.0 - IL_0020: dup - IL_0021: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0026: ldc.i4.2 - IL_0027: add - IL_0028: conv.i2 - IL_0029: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_002e: ldarg.0 - IL_002f: dup - IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0035: ldc.i4.3 - IL_0036: sub - IL_0037: conv.i2 - IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_003d: ret - } // end of method CompoundAssignmentTest::ShortEnumTest + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: dup + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.u2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.u2 + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.u2 + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0063: ldc.i4.1 + IL_0064: sub + IL_0065: conv.u2 + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_007c: ldc.i4.1 + IL_007d: sub + IL_007e: conv.u2 + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0099: ldc.i4.1 + IL_009a: sub + IL_009b: conv.u2 + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b5: ldc.i4.1 + IL_00b6: sub + IL_00b7: conv.u2 + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.u2 + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00ee: ldc.i4.1 + IL_00ef: sub + IL_00f0: conv.u2 + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010b: ldc.i4.1 + IL_010c: sub + IL_010d: conv.u2 + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0127: ldc.i4.1 + IL_0128: sub + IL_0129: conv.u2 + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0144: ldc.i4.1 + IL_0145: sub + IL_0146: conv.u2 + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0160: ldc.i4.1 + IL_0161: sub + IL_0162: conv.u2 + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UshortPreDecTest - .method public hidebysig instance int32 - PreIncrementInAddition(int32 i, - int32 j) cil managed + .method public hidebysig static void IntAddTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldc.i4.1 - IL_0004: add - IL_0005: dup - IL_0006: starg.s j - IL_0008: add - IL_0009: stloc.0 - IL_000a: br.s IL_000c + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: add + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: add + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: add + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: add + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: add + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: add + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: add + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: add + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: add + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntAddTest - IL_000c: ldloc.0 - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementInAddition + .method public hidebysig static void IntSubtractTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: sub + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: sub + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: sub + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: sub + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: sub + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: sub + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: sub + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: sub + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: sub + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntSubtractTest - .method public hidebysig instance int32 - PreIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntMultiplyTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int32 - IL_000e: ldc.i4.1 - IL_000f: sub - IL_0010: dup - IL_0011: stloc.1 - IL_0012: stobj [mscorlib]System.Int32 - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: mul + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: mul + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: mul + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: mul + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: mul + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: mul + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: mul + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: mul + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: mul + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntMultiplyTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElement + .method public hidebysig static void IntDivideTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: div + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: div + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: div + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: div + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: div + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: div + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: div + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: div + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: div + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: div + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: div + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntDivideTest - .method public hidebysig instance int32 - PostIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntModulusTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int32 - IL_000e: dup - IL_000f: stloc.1 - IL_0010: ldc.i4.1 - IL_0011: add - IL_0012: stobj [mscorlib]System.Int32 - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: rem + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: rem + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: rem + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: rem + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: rem + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: rem + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: rem + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: rem + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: rem + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: rem + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntModulusTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElement + .method public hidebysig static void IntLeftShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: shl + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: shl + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: shl + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: shl + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: shl + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: shl + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: shl + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: shl + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntLeftShiftTest - .method public hidebysig instance void - IncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntRightShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int32 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: stobj [mscorlib]System.Int32 - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementArrayElement + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: shr + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: shr + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: shr + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: shr + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: shr + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: shr + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: shr + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: shr + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: shr + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntRightShiftTest - .method public hidebysig instance void - DoubleArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntBitAndTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int32 - IL_000e: ldc.i4.2 - IL_000f: mul - IL_0010: stobj [mscorlib]System.Int32 - IL_0015: ret - } // end of method CompoundAssignmentTest::DoubleArrayElement + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: and + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: and + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: and + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: and + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: and + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: and + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: and + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: and + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: and + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntBitAndTest - .method public hidebysig instance int32 - DoubleArrayElementAndReturn(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntBitOrTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int32 - IL_000e: ldc.i4.2 - IL_000f: mul - IL_0010: dup - IL_0011: stloc.1 - IL_0012: stobj [mscorlib]System.Int32 - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: or + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: or + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: or + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: or + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: or + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: or + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: or + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: or + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: or + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntBitOrTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + .method public hidebysig static void IntBitXorTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: xor + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003f: ldc.i4.5 + IL_0040: xor + IL_0041: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004e: ldc.i4.5 + IL_004f: xor + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldc.i4.5 + IL_0062: xor + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0086: ldc.i4.5 + IL_0087: xor + IL_0088: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0098: ldc.i4.5 + IL_0099: xor + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ab: ldc.i4.5 + IL_00ac: xor + IL_00ad: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00bd: ldc.i4.5 + IL_00be: xor + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: ldc.i4.5 + IL_00d1: xor + IL_00d2: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::IntBitXorTest - .method public hidebysig instance int32 - PreIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntPostIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 357 (0x165) .maxstack 3 - .locals init (int32 V_0, - int16 V_1) + .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: dup + IL_0030: stloc.0 + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: dup + IL_0047: stloc.0 + IL_0048: ldc.i4.1 + IL_0049: add + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005f: dup + IL_0060: stloc.0 + IL_0061: ldc.i4.1 + IL_0062: add + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0077: dup + IL_0078: stloc.0 + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: dup + IL_0094: stloc.0 + IL_0095: ldc.i4.1 + IL_0096: add + IL_0097: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ae: dup + IL_00af: stloc.0 + IL_00b0: ldc.i4.1 + IL_00b1: add + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ca: dup + IL_00cb: stloc.0 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00e5: dup + IL_00e6: stloc.0 + IL_00e7: ldc.i4.1 + IL_00e8: add + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0101: dup + IL_0102: stloc.0 + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_011c: dup + IL_011d: stloc.0 + IL_011e: ldc.i4.1 + IL_011f: add + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0138: dup + IL_0139: stloc.0 + IL_013a: ldc.i4.1 + IL_013b: add + IL_013c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0153: dup + IL_0154: stloc.0 + IL_0155: ldc.i4.1 + IL_0156: add + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::IntPostIncTest + + .method public hidebysig static void IntPreIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 357 (0x165) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.1 + IL_0007: add IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int16 - IL_000e: ldc.i4.1 - IL_000f: sub - IL_0010: conv.i2 - IL_0011: dup - IL_0012: stloc.1 - IL_0013: stobj [mscorlib]System.Int16 - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: dup + IL_0032: stloc.0 + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: dup + IL_0049: stloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: dup + IL_0062: stloc.0 + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0077: ldc.i4.1 + IL_0078: add + IL_0079: dup + IL_007a: stloc.0 + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldc.i4.1 + IL_0094: add + IL_0095: dup + IL_0096: stloc.0 + IL_0097: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ae: ldc.i4.1 + IL_00af: add + IL_00b0: dup + IL_00b1: stloc.0 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ca: ldc.i4.1 + IL_00cb: add + IL_00cc: dup + IL_00cd: stloc.0 + IL_00ce: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00e5: ldc.i4.1 + IL_00e6: add + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0101: ldc.i4.1 + IL_0102: add + IL_0103: dup + IL_0104: stloc.0 + IL_0105: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_011c: ldc.i4.1 + IL_011d: add + IL_011e: dup + IL_011f: stloc.0 + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0138: ldc.i4.1 + IL_0139: add + IL_013a: dup + IL_013b: stloc.0 + IL_013c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0153: ldc.i4.1 + IL_0154: add + IL_0155: dup + IL_0156: stloc.0 + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::IntPreIncTest - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + .method public hidebysig static void IntPostDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 357 (0x165) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: dup + IL_0030: stloc.0 + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: dup + IL_0047: stloc.0 + IL_0048: ldc.i4.1 + IL_0049: sub + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005f: dup + IL_0060: stloc.0 + IL_0061: ldc.i4.1 + IL_0062: sub + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0077: dup + IL_0078: stloc.0 + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: dup + IL_0094: stloc.0 + IL_0095: ldc.i4.1 + IL_0096: sub + IL_0097: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ae: dup + IL_00af: stloc.0 + IL_00b0: ldc.i4.1 + IL_00b1: sub + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ca: dup + IL_00cb: stloc.0 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00e5: dup + IL_00e6: stloc.0 + IL_00e7: ldc.i4.1 + IL_00e8: sub + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0101: dup + IL_0102: stloc.0 + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_011c: dup + IL_011d: stloc.0 + IL_011e: ldc.i4.1 + IL_011f: sub + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0138: dup + IL_0139: stloc.0 + IL_013a: ldc.i4.1 + IL_013b: sub + IL_013c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0153: dup + IL_0154: stloc.0 + IL_0155: ldc.i4.1 + IL_0156: sub + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::IntPostDecTest - .method public hidebysig instance int32 - PostIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void IntPreDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 357 (0x165) .maxstack 3 - .locals init (int32 V_0, - int16 V_1) + .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.1 + IL_0007: sub IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int16 - IL_000e: dup - IL_000f: stloc.1 - IL_0010: ldc.i4.1 - IL_0011: add - IL_0012: conv.i2 - IL_0013: stobj [mscorlib]System.Int16 - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c - - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: dup + IL_0032: stloc.0 + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: dup + IL_0049: stloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: dup + IL_0062: stloc.0 + IL_0063: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0077: ldc.i4.1 + IL_0078: sub + IL_0079: dup + IL_007a: stloc.0 + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldc.i4.1 + IL_0094: sub + IL_0095: dup + IL_0096: stloc.0 + IL_0097: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ae: ldc.i4.1 + IL_00af: sub + IL_00b0: dup + IL_00b1: stloc.0 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ca: ldc.i4.1 + IL_00cb: sub + IL_00cc: dup + IL_00cd: stloc.0 + IL_00ce: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00e5: ldc.i4.1 + IL_00e6: sub + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0101: ldc.i4.1 + IL_0102: sub + IL_0103: dup + IL_0104: stloc.0 + IL_0105: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_011c: ldc.i4.1 + IL_011d: sub + IL_011e: dup + IL_011f: stloc.0 + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0138: ldc.i4.1 + IL_0139: sub + IL_013a: dup + IL_013b: stloc.0 + IL_013c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0153: ldc.i4.1 + IL_0154: sub + IL_0155: dup + IL_0156: stloc.0 + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::IntPreDecTest - .method public hidebysig instance void - IncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintAddTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int16 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.i2 - IL_0011: stobj [mscorlib]System.Int16 - IL_0016: ret - } // end of method CompoundAssignmentTest::IncrementArrayElementShort + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: add + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: add + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: add + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: add + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: add + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: add + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: add + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: add + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: add + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintAddTest - .method public hidebysig instance void - DoubleArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintSubtractTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int16 - IL_000e: ldc.i4.2 - IL_000f: mul - IL_0010: conv.i2 - IL_0011: stobj [mscorlib]System.Int16 - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShort + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: sub + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: sub + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: sub + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: sub + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: sub + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: sub + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: sub + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: sub + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: sub + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintSubtractTest - .method public hidebysig instance int16 - DoubleArrayElementShortAndReturn(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintMultiplyTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int16 V_0, - int16 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldobj [mscorlib]System.Int16 - IL_000e: ldc.i4.2 - IL_000f: mul - IL_0010: conv.i2 - IL_0011: dup - IL_0012: stloc.1 - IL_0013: stobj [mscorlib]System.Int16 - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c - - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: mul + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: mul + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: mul + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: mul + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: mul + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: mul + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: mul + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: mul + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: mul + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintMultiplyTest - .method public hidebysig instance int32 - PreIncrementInstanceField() cil managed + .method public hidebysig static void UintDivideTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: dup - IL_0010: stloc.1 - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.1 - IL_0017: stloc.0 - IL_0018: br.s IL_001a + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: div.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: div.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: div.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: div.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: div.un + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: div.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: div.un + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: div.un + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: div.un + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: div.un + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: div.un + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: div.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: div.un + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: div.un + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintDivideTest - IL_001a: ldloc.0 - IL_001b: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField + .method public hidebysig static void UintModulusTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: rem.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: rem.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: rem.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: rem.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: rem.un + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: rem.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: rem.un + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: rem.un + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: rem.un + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: rem.un + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: rem.un + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: rem.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: rem.un + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem.un + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintModulusTest - .method public hidebysig instance int32 - PostIncrementInstanceField() cil managed + .method public hidebysig static void UintLeftShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: dup - IL_000e: stloc.1 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.1 - IL_0017: stloc.0 - IL_0018: br.s IL_001a + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: shl + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: shl + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: shl + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: shl + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: shl + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: shl + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: shl + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: shl + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintLeftShiftTest - IL_001a: ldloc.0 - IL_001b: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField + .method public hidebysig static void UintRightShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 235 (0xeb) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: shr.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: shr.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: shr.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: shr.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: shr.un + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: shr.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: shr.un + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: shr.un + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: shr.un + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: shr.un + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: shr.un + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: shr.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: shr.un + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr.un + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintRightShiftTest - .method public hidebysig instance void - IncrementInstanceField() cil managed + .method public hidebysig static void UintBitAndTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: and + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: and + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: and + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: and + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: and + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: and + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: and + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: and + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: and + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintBitAndTest - .method public hidebysig instance void - DoubleInstanceField() cil managed + .method public hidebysig static void UintBitOrTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleInstanceField + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: or + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: or + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: or + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: or + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: or + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: or + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: or + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: or + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: or + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintBitOrTest - .method public hidebysig instance int32 - DoubleInstanceFieldAndReturn() cil managed + .method public hidebysig static void UintBitXorTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: dup - IL_0010: stloc.1 - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.1 - IL_0017: stloc.0 - IL_0018: br.s IL_001a + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: xor + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003f: ldc.i4.5 + IL_0040: xor + IL_0041: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004e: ldc.i4.5 + IL_004f: xor + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldc.i4.5 + IL_0062: xor + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0086: ldc.i4.5 + IL_0087: xor + IL_0088: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0098: ldc.i4.5 + IL_0099: xor + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ab: ldc.i4.5 + IL_00ac: xor + IL_00ad: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00bd: ldc.i4.5 + IL_00be: xor + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: ldc.i4.5 + IL_00d1: xor + IL_00d2: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UintBitXorTest - IL_001a: ldloc.0 - IL_001b: ret - } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + .method public hidebysig static void UintPostIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 357 (0x165) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: dup + IL_0030: stloc.0 + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: dup + IL_0047: stloc.0 + IL_0048: ldc.i4.1 + IL_0049: add + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005f: dup + IL_0060: stloc.0 + IL_0061: ldc.i4.1 + IL_0062: add + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0077: dup + IL_0078: stloc.0 + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: dup + IL_0094: stloc.0 + IL_0095: ldc.i4.1 + IL_0096: add + IL_0097: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ae: dup + IL_00af: stloc.0 + IL_00b0: ldc.i4.1 + IL_00b1: add + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ca: dup + IL_00cb: stloc.0 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00e5: dup + IL_00e6: stloc.0 + IL_00e7: ldc.i4.1 + IL_00e8: add + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0101: dup + IL_0102: stloc.0 + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_011c: dup + IL_011d: stloc.0 + IL_011e: ldc.i4.1 + IL_011f: add + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0138: dup + IL_0139: stloc.0 + IL_013a: ldc.i4.1 + IL_013b: add + IL_013c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0153: dup + IL_0154: stloc.0 + IL_0155: ldc.i4.1 + IL_0156: add + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::UintPostIncTest - .method public hidebysig instance int32 - PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UintPreIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 357 (0x165) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (uint32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: dup - IL_000b: stloc.1 - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0011: ldloc.1 - IL_0012: stloc.0 - IL_0013: br.s IL_0015 + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: dup + IL_0032: stloc.0 + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: dup + IL_0049: stloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: dup + IL_0062: stloc.0 + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0077: ldc.i4.1 + IL_0078: add + IL_0079: dup + IL_007a: stloc.0 + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldc.i4.1 + IL_0094: add + IL_0095: dup + IL_0096: stloc.0 + IL_0097: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ae: ldc.i4.1 + IL_00af: add + IL_00b0: dup + IL_00b1: stloc.0 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ca: ldc.i4.1 + IL_00cb: add + IL_00cc: dup + IL_00cd: stloc.0 + IL_00ce: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00e5: ldc.i4.1 + IL_00e6: add + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0101: ldc.i4.1 + IL_0102: add + IL_0103: dup + IL_0104: stloc.0 + IL_0105: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_011c: ldc.i4.1 + IL_011d: add + IL_011e: dup + IL_011f: stloc.0 + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0138: ldc.i4.1 + IL_0139: add + IL_013a: dup + IL_013b: stloc.0 + IL_013c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0153: ldc.i4.1 + IL_0154: add + IL_0155: dup + IL_0156: stloc.0 + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::UintPreIncTest - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + .method public hidebysig static void UintPostDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 357 (0x165) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: dup + IL_0030: stloc.0 + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: dup + IL_0047: stloc.0 + IL_0048: ldc.i4.1 + IL_0049: sub + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005f: dup + IL_0060: stloc.0 + IL_0061: ldc.i4.1 + IL_0062: sub + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0077: dup + IL_0078: stloc.0 + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: dup + IL_0094: stloc.0 + IL_0095: ldc.i4.1 + IL_0096: sub + IL_0097: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ae: dup + IL_00af: stloc.0 + IL_00b0: ldc.i4.1 + IL_00b1: sub + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ca: dup + IL_00cb: stloc.0 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00e5: dup + IL_00e6: stloc.0 + IL_00e7: ldc.i4.1 + IL_00e8: sub + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0101: dup + IL_0102: stloc.0 + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_011c: dup + IL_011d: stloc.0 + IL_011e: ldc.i4.1 + IL_011f: sub + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0138: dup + IL_0139: stloc.0 + IL_013a: ldc.i4.1 + IL_013b: sub + IL_013c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0153: dup + IL_0154: stloc.0 + IL_0155: ldc.i4.1 + IL_0156: sub + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::UintPostDecTest - .method public hidebysig instance int32 - PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UintPreDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 357 (0x165) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (uint32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.1 + IL_0007: sub IL_0008: dup - IL_0009: stloc.1 - IL_000a: ldc.i4.1 - IL_000b: add - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0011: ldloc.1 - IL_0012: stloc.0 - IL_0013: br.s IL_0015 - - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: dup + IL_0032: stloc.0 + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: dup + IL_0049: stloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: dup + IL_0062: stloc.0 + IL_0063: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0068: ldloc.0 + IL_0069: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006e: nop + IL_006f: ldarga.s s + IL_0071: dup + IL_0072: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0077: ldc.i4.1 + IL_0078: sub + IL_0079: dup + IL_007a: stloc.0 + IL_007b: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0080: nop + IL_0081: ldloc.0 + IL_0082: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0087: nop + IL_0088: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008d: dup + IL_008e: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldc.i4.1 + IL_0094: sub + IL_0095: dup + IL_0096: stloc.0 + IL_0097: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009c: ldloc.0 + IL_009d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ae: ldc.i4.1 + IL_00af: sub + IL_00b0: dup + IL_00b1: stloc.0 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b7: nop + IL_00b8: ldloc.0 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: nop + IL_00bf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ca: ldc.i4.1 + IL_00cb: sub + IL_00cc: dup + IL_00cd: stloc.0 + IL_00ce: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00d3: ldloc.0 + IL_00d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d9: nop + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00e5: ldc.i4.1 + IL_00e6: sub + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00ee: nop + IL_00ef: ldloc.0 + IL_00f0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f5: nop + IL_00f6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fb: dup + IL_00fc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0101: ldc.i4.1 + IL_0102: sub + IL_0103: dup + IL_0104: stloc.0 + IL_0105: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_010a: ldloc.0 + IL_010b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0110: nop + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0116: dup + IL_0117: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_011c: ldc.i4.1 + IL_011d: sub + IL_011e: dup + IL_011f: stloc.0 + IL_0120: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0125: nop + IL_0126: ldloc.0 + IL_0127: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012c: nop + IL_012d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0132: dup + IL_0133: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0138: ldc.i4.1 + IL_0139: sub + IL_013a: dup + IL_013b: stloc.0 + IL_013c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0141: ldloc.0 + IL_0142: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0147: nop + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0153: ldc.i4.1 + IL_0154: sub + IL_0155: dup + IL_0156: stloc.0 + IL_0157: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_015c: nop + IL_015d: ldloc.0 + IL_015e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0163: nop + IL_0164: ret + } // end of method CompoundAssignmentTest::UintPreDecTest - .method public hidebysig instance void - IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void LongAddTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: add + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: add + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: add + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: add + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: add + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: add + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: add + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: add + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: add + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: add + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: add + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: add + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: add + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongAddTest + + .method public hidebysig static void LongSubtractTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 16 (0x10) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000f: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField2 + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: sub + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: sub + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: sub + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: sub + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: sub + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: sub + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: sub + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: sub + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: sub + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: sub + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: sub + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: sub + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: sub + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongSubtractTest - .method public hidebysig instance int32 - PreIncrementInstanceFieldShort() cil managed + .method public hidebysig static void LongMultiplyTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0, - int16 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.i2 - IL_0010: dup - IL_0011: stloc.1 - IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b - - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: mul + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: mul + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: mul + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: mul + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: mul + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: mul + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: mul + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: mul + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: mul + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: mul + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: mul + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: mul + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: mul + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: mul + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongMultiplyTest - .method public hidebysig instance int32 - PostIncrementInstanceFieldShort() cil managed + .method public hidebysig static void LongDivideTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0, - int16 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: dup - IL_000e: stloc.1 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.i2 - IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: div + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: div + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: div + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: div + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: div + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: div + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: div + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: div + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: div + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: div + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: div + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: div + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: div + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: div + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongDivideTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + .method public hidebysig static void LongModulusTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: rem + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: rem + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: rem + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: rem + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: rem + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: rem + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: rem + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: rem + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: rem + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: rem + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: rem + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: rem + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: rem + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: rem + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongModulusTest - .method public hidebysig instance void - IncrementInstanceFieldShort() cil managed + .method public hidebysig static void LongLeftShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.i2 - IL_0010: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: ldc.i4.5 + IL_0040: shl + IL_0041: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004e: ldc.i4.5 + IL_004f: shl + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0061: ldc.i4.5 + IL_0062: shl + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0086: ldc.i4.5 + IL_0087: shl + IL_0088: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0098: ldc.i4.5 + IL_0099: shl + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ab: ldc.i4.5 + IL_00ac: shl + IL_00ad: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bd: ldc.i4.5 + IL_00be: shl + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d0: ldc.i4.5 + IL_00d1: shl + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::LongLeftShiftTest - .method public hidebysig instance int32 - PreIncrementInstanceProperty() cil managed + .method public hidebysig static void LongRightShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: dup - IL_0010: stloc.1 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002f: ldc.i4.5 + IL_0030: shr + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: ldc.i4.5 + IL_0040: shr + IL_0041: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004e: ldc.i4.5 + IL_004f: shr + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0061: ldc.i4.5 + IL_0062: shr + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0086: ldc.i4.5 + IL_0087: shr + IL_0088: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0098: ldc.i4.5 + IL_0099: shr + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ab: ldc.i4.5 + IL_00ac: shr + IL_00ad: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bd: ldc.i4.5 + IL_00be: shr + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d0: ldc.i4.5 + IL_00d1: shr + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::LongRightShiftTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + .method public hidebysig static void LongBitAndTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: and + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: and + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: and + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: and + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: and + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: and + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: and + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: and + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: and + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: and + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: and + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: and + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: and + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: and + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongBitAndTest - .method public hidebysig instance int32 - PostIncrementInstanceProperty() cil managed + .method public hidebysig static void LongBitOrTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: dup - IL_000e: stloc.1 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: or + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: or + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: or + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: or + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: or + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: or + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: or + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: or + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: or + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: or + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: or + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: or + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: or + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: or + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongBitOrTest - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + .method public hidebysig static void LongBitXorTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: xor + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: xor + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: xor + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: xor + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: xor + IL_0046: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: xor + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: xor + IL_006a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: xor + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: xor + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: xor + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: xor + IL_00b8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: xor + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: xor + IL_00df: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: xor + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::LongBitXorTest - .method public hidebysig instance void - IncrementInstanceProperty() cil managed + .method public hidebysig static void LongPostIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: add + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) IL_0014: nop - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementInstanceProperty + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: add + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: add + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: add + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: conv.i8 + IL_0067: add + IL_0068: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: conv.i8 + IL_0080: add + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: conv.i8 + IL_009d: add + IL_009e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: conv.i8 + IL_00b9: add + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: conv.i8 + IL_00d6: add + IL_00d7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: conv.i8 + IL_00f2: add + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: conv.i8 + IL_010f: add + IL_0110: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: conv.i8 + IL_012b: add + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: add + IL_0149: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: add + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::LongPostIncTest - .method public hidebysig instance void - DoubleInstanceProperty() cil managed + .method public hidebysig static void LongPreIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: dup + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) IL_0014: nop - IL_0015: ret - } // end of method CompoundAssignmentTest::DoubleInstanceProperty + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: add + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: add + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: add + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0063: ldc.i4.1 + IL_0064: conv.i8 + IL_0065: add + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_007c: ldc.i4.1 + IL_007d: conv.i8 + IL_007e: add + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0099: ldc.i4.1 + IL_009a: conv.i8 + IL_009b: add + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b5: ldc.i4.1 + IL_00b6: conv.i8 + IL_00b7: add + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: add + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00ee: ldc.i4.1 + IL_00ef: conv.i8 + IL_00f0: add + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010b: ldc.i4.1 + IL_010c: conv.i8 + IL_010d: add + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0127: ldc.i4.1 + IL_0128: conv.i8 + IL_0129: add + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0144: ldc.i4.1 + IL_0145: conv.i8 + IL_0146: add + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0160: ldc.i4.1 + IL_0161: conv.i8 + IL_0162: add + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::LongPreIncTest - .method public hidebysig instance int32 - DoubleInstancePropertyAndReturn() cil managed + .method public hidebysig static void LongPostDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 371 (0x173) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: dup - IL_0010: stloc.1 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.1 - IL_0018: stloc.0 - IL_0019: br.s IL_001b - - IL_001b: ldloc.0 - IL_001c: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: sub + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: sub + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: sub + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: sub + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: conv.i8 + IL_0067: sub + IL_0068: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: conv.i8 + IL_0080: sub + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: conv.i8 + IL_009d: sub + IL_009e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: conv.i8 + IL_00b9: sub + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: conv.i8 + IL_00d6: sub + IL_00d7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: conv.i8 + IL_00f2: sub + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: conv.i8 + IL_010f: sub + IL_0110: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: conv.i8 + IL_012b: sub + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: sub + IL_0149: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: sub + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::LongPostDecTest - .method public hidebysig instance int32 - PreIncrementInstancePropertyByte() cil managed + .method public hidebysig static void LongPreDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 371 (0x173) .maxstack 3 - .locals init (int32 V_0, - uint8 V_1) + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.u1 - IL_0010: dup - IL_0011: stloc.1 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: dup + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: sub + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: sub + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: sub + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0063: ldc.i4.1 + IL_0064: conv.i8 + IL_0065: sub + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_007c: ldc.i4.1 + IL_007d: conv.i8 + IL_007e: sub + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0099: ldc.i4.1 + IL_009a: conv.i8 + IL_009b: sub + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b5: ldc.i4.1 + IL_00b6: conv.i8 + IL_00b7: sub + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: sub + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00ee: ldc.i4.1 + IL_00ef: conv.i8 + IL_00f0: sub + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010b: ldc.i4.1 + IL_010c: conv.i8 + IL_010d: sub + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0127: ldc.i4.1 + IL_0128: conv.i8 + IL_0129: sub + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0144: ldc.i4.1 + IL_0145: conv.i8 + IL_0146: sub + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0160: ldc.i4.1 + IL_0161: conv.i8 + IL_0162: sub + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::LongPreDecTest - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + .method public hidebysig static void UlongAddTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: add + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: add + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: add + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: add + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: add + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: add + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: add + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: add + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: add + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: add + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: add + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: add + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: add + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongAddTest - .method public hidebysig instance int32 - PostIncrementInstancePropertyByte() cil managed + .method public hidebysig static void UlongSubtractTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: sub + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: sub + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: sub + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: sub + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: sub + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: sub + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: sub + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: sub + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: sub + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: sub + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: sub + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: sub + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: sub + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongSubtractTest + + .method public hidebysig static void UlongMultiplyTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 249 (0xf9) .maxstack 3 - .locals init (int32 V_0, - uint8 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: dup - IL_000e: stloc.1 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.u1 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: mul + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: mul + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: mul + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: mul + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: mul + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: mul + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: mul + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: mul + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: mul + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: mul + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: mul + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: mul + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: mul + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: mul + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongMultiplyTest - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + .method public hidebysig static void UlongDivideTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: div.un + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: div.un + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: div.un + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: div.un + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: div.un + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: div.un + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: div.un + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: div.un + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: div.un + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: div.un + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: div.un + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: div.un + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: div.un + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: div.un + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongDivideTest - .method public hidebysig instance void - IncrementInstancePropertyByte() cil managed + .method public hidebysig static void UlongModulusTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) - .maxstack 8 + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.u1 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0015: nop - IL_0016: ret - } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: rem.un + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: rem.un + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: rem.un + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: rem.un + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: rem.un + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: rem.un + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: rem.un + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: rem.un + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: rem.un + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: rem.un + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: rem.un + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: rem.un + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: rem.un + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: rem.un + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongModulusTest - .method public hidebysig instance void - DoubleInstancePropertyByte() cil managed + .method public hidebysig static void UlongLeftShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) - .maxstack 8 + // Code size 235 (0xeb) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.u1 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0015: nop - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: ldc.i4.5 + IL_0040: shl + IL_0041: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004e: ldc.i4.5 + IL_004f: shl + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0061: ldc.i4.5 + IL_0062: shl + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0086: ldc.i4.5 + IL_0087: shl + IL_0088: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0098: ldc.i4.5 + IL_0099: shl + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ab: ldc.i4.5 + IL_00ac: shl + IL_00ad: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bd: ldc.i4.5 + IL_00be: shl + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d0: ldc.i4.5 + IL_00d1: shl + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UlongLeftShiftTest - .method public hidebysig instance int32 - DoubleInstancePropertyByteAndReturn() cil managed + .method public hidebysig static void UlongRightShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 235 (0xeb) .maxstack 3 - .locals init (int32 V_0, - uint8 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.u1 - IL_0010: dup - IL_0011: stloc.1 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.1 - IL_0019: stloc.0 - IL_001a: br.s IL_001c + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: shr.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: shr.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: shr.un + IL_0023: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002f: ldc.i4.5 + IL_0030: shr.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: dup + IL_003a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: ldc.i4.5 + IL_0040: shr.un + IL_0041: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0046: ldarga.s s + IL_0048: dup + IL_0049: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004e: ldc.i4.5 + IL_004f: shr.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: nop + IL_0056: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005b: dup + IL_005c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0061: ldc.i4.5 + IL_0062: shr.un + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: shr.un + IL_0075: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007a: nop + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: dup + IL_0081: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0086: ldc.i4.5 + IL_0087: shr.un + IL_0088: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008d: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0092: dup + IL_0093: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0098: ldc.i4.5 + IL_0099: shr.un + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009f: nop + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a5: dup + IL_00a6: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ab: ldc.i4.5 + IL_00ac: shr.un + IL_00ad: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b7: dup + IL_00b8: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bd: ldc.i4.5 + IL_00be: shr.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: nop + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ca: dup + IL_00cb: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d0: ldc.i4.5 + IL_00d1: shr.un + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr.un + IL_00e4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e9: nop + IL_00ea: ret + } // end of method CompoundAssignmentTest::UlongRightShiftTest - IL_001c: ldloc.0 - IL_001d: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + .method public hidebysig static void UlongBitAndTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: and + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: and + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: and + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: and + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: and + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: and + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: and + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: and + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: and + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: and + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: and + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: and + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: and + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: and + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongBitAndTest - .method public hidebysig instance int32 - PreIncrementStaticField() cil managed + .method public hidebysig static void UlongBitOrTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 2 - .locals init (int32 V_0) + // Code size 249 (0xf9) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: dup - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: or + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: or + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: or + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: or + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: or + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: or + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: or + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: or + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: or + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: or + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: or + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: or + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: or + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: or + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongBitOrTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticField + .method public hidebysig static void UlongBitXorTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 249 (0xf9) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: xor + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: xor + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: xor + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: xor + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: dup + IL_003e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldc.i4.5 + IL_0044: conv.i8 + IL_0045: xor + IL_0046: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_004b: ldarga.s s + IL_004d: dup + IL_004e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0053: ldc.i4.5 + IL_0054: conv.i8 + IL_0055: xor + IL_0056: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_005b: nop + IL_005c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0061: dup + IL_0062: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0067: ldc.i4.5 + IL_0068: conv.i8 + IL_0069: xor + IL_006a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_007a: ldc.i4.5 + IL_007b: conv.i8 + IL_007c: xor + IL_007d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0082: nop + IL_0083: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0088: dup + IL_0089: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008e: ldc.i4.5 + IL_008f: conv.i8 + IL_0090: xor + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00a1: ldc.i4.5 + IL_00a2: conv.i8 + IL_00a3: xor + IL_00a4: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a9: nop + IL_00aa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00af: dup + IL_00b0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b5: ldc.i4.5 + IL_00b6: conv.i8 + IL_00b7: xor + IL_00b8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c2: dup + IL_00c3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c8: ldc.i4.5 + IL_00c9: conv.i8 + IL_00ca: xor + IL_00cb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00d0: nop + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dc: ldc.i4.5 + IL_00dd: conv.i8 + IL_00de: xor + IL_00df: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e9: dup + IL_00ea: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ef: ldc.i4.5 + IL_00f0: conv.i8 + IL_00f1: xor + IL_00f2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f7: nop + IL_00f8: ret + } // end of method CompoundAssignmentTest::UlongBitXorTest - .method public hidebysig instance int32 - PostIncrementStaticField() cil managed + .method public hidebysig static void UlongPostIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) + // Code size 371 (0x173) .maxstack 3 - .locals init (int32 V_0) + .locals init (uint64 V_0) IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField IL_0006: dup IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: add + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: add + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: add + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: add + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: conv.i8 + IL_0067: add + IL_0068: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: conv.i8 + IL_0080: add + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: conv.i8 + IL_009d: add + IL_009e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: conv.i8 + IL_00b9: add + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: conv.i8 + IL_00d6: add + IL_00d7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: conv.i8 + IL_00f2: add + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: conv.i8 + IL_010f: add + IL_0110: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: conv.i8 + IL_012b: add + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: add + IL_0149: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: add + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UlongPostIncTest + + .method public hidebysig static void UlongPreIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint64 V_0) + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 IL_0008: add - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0009: dup + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: add + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: add + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: add + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0063: ldc.i4.1 + IL_0064: conv.i8 + IL_0065: add + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_007c: ldc.i4.1 + IL_007d: conv.i8 + IL_007e: add + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0099: ldc.i4.1 + IL_009a: conv.i8 + IL_009b: add + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b5: ldc.i4.1 + IL_00b6: conv.i8 + IL_00b7: add + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: add + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00ee: ldc.i4.1 + IL_00ef: conv.i8 + IL_00f0: add + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010b: ldc.i4.1 + IL_010c: conv.i8 + IL_010d: add + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0127: ldc.i4.1 + IL_0128: conv.i8 + IL_0129: add + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0144: ldc.i4.1 + IL_0145: conv.i8 + IL_0146: add + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0160: ldc.i4.1 + IL_0161: conv.i8 + IL_0162: add + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UlongPreIncTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticField + .method public hidebysig static void UlongPostDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint64 V_0) + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: sub + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: sub + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: sub + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: dup + IL_004a: stloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: sub + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0063: dup + IL_0064: stloc.0 + IL_0065: ldc.i4.1 + IL_0066: conv.i8 + IL_0067: sub + IL_0068: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_007c: dup + IL_007d: stloc.0 + IL_007e: ldc.i4.1 + IL_007f: conv.i8 + IL_0080: sub + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0099: dup + IL_009a: stloc.0 + IL_009b: ldc.i4.1 + IL_009c: conv.i8 + IL_009d: sub + IL_009e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b5: dup + IL_00b6: stloc.0 + IL_00b7: ldc.i4.1 + IL_00b8: conv.i8 + IL_00b9: sub + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d2: dup + IL_00d3: stloc.0 + IL_00d4: ldc.i4.1 + IL_00d5: conv.i8 + IL_00d6: sub + IL_00d7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00ee: dup + IL_00ef: stloc.0 + IL_00f0: ldc.i4.1 + IL_00f1: conv.i8 + IL_00f2: sub + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010b: dup + IL_010c: stloc.0 + IL_010d: ldc.i4.1 + IL_010e: conv.i8 + IL_010f: sub + IL_0110: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0127: dup + IL_0128: stloc.0 + IL_0129: ldc.i4.1 + IL_012a: conv.i8 + IL_012b: sub + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0144: dup + IL_0145: stloc.0 + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: sub + IL_0149: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0160: dup + IL_0161: stloc.0 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: sub + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UlongPostDecTest - .method public hidebysig instance void - IncrementStaticField() cil managed + .method public hidebysig static void UlongPreDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 371 (0x173) + .maxstack 3 + .locals init (uint64 V_0) IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticField + IL_0007: conv.i8 + IL_0008: sub + IL_0009: dup + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: sub + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: sub + IL_0034: dup + IL_0035: stloc.0 + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: sub + IL_004c: dup + IL_004d: stloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0063: ldc.i4.1 + IL_0064: conv.i8 + IL_0065: sub + IL_0066: dup + IL_0067: stloc.0 + IL_0068: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: nop + IL_0074: ldarga.s s + IL_0076: dup + IL_0077: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_007c: ldc.i4.1 + IL_007d: conv.i8 + IL_007e: sub + IL_007f: dup + IL_0080: stloc.0 + IL_0081: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0086: nop + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: nop + IL_008e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0093: dup + IL_0094: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0099: ldc.i4.1 + IL_009a: conv.i8 + IL_009b: sub + IL_009c: dup + IL_009d: stloc.0 + IL_009e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a3: ldloc.0 + IL_00a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a9: nop + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b5: ldc.i4.1 + IL_00b6: conv.i8 + IL_00b7: sub + IL_00b8: dup + IL_00b9: stloc.0 + IL_00ba: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bf: nop + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: nop + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: dup + IL_00cd: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: sub + IL_00d5: dup + IL_00d6: stloc.0 + IL_00d7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00dc: ldloc.0 + IL_00dd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e2: nop + IL_00e3: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e8: dup + IL_00e9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00ee: ldc.i4.1 + IL_00ef: conv.i8 + IL_00f0: sub + IL_00f1: dup + IL_00f2: stloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f8: nop + IL_00f9: ldloc.0 + IL_00fa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ff: nop + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0105: dup + IL_0106: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010b: ldc.i4.1 + IL_010c: conv.i8 + IL_010d: sub + IL_010e: dup + IL_010f: stloc.0 + IL_0110: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: nop + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0127: ldc.i4.1 + IL_0128: conv.i8 + IL_0129: sub + IL_012a: dup + IL_012b: stloc.0 + IL_012c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0131: nop + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: nop + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013e: dup + IL_013f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0144: ldc.i4.1 + IL_0145: conv.i8 + IL_0146: sub + IL_0147: dup + IL_0148: stloc.0 + IL_0149: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_014e: ldloc.0 + IL_014f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0160: ldc.i4.1 + IL_0161: conv.i8 + IL_0162: sub + IL_0163: dup + IL_0164: stloc.0 + IL_0165: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_016a: nop + IL_016b: ldloc.0 + IL_016c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0171: nop + IL_0172: ret + } // end of method CompoundAssignmentTest::UlongPreDecTest - .method public hidebysig instance void - DoubleStaticField() cil managed + .method public hidebysig static void CustomClassAddTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 291 (0x123) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticField + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassAddTest - .method public hidebysig instance int32 - DoubleStaticFieldAndReturn() cil managed + .method public hidebysig static void CustomClassSubtractTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 2 - .locals init (int32 V_0) + // Code size 291 (0x123) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: dup - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassSubtractTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + .method public hidebysig static void CustomClassMultiplyTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassMultiplyTest - .method public hidebysig instance int32 - PreIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomClassDivideTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int32 V_0) + // Code size 291 (0x123) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: dup - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassDivideTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + .method public hidebysig static void CustomClassModulusTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassModulusTest + + .method public hidebysig static void CustomClassLeftShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldc.i4.5 + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldc.i4.5 + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldc.i4.5 + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldc.i4.5 + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldc.i4.5 + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldc.i4.5 + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldc.i4.5 + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldc.i4.5 + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldc.i4.5 + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldc.i4.5 + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldc.i4.5 + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldc.i4.5 + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldc.i4.5 + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldc.i4.5 + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassLeftShiftTest + + .method public hidebysig static void CustomClassRightShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldc.i4.5 + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldc.i4.5 + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldc.i4.5 + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldc.i4.5 + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldc.i4.5 + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldc.i4.5 + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldc.i4.5 + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldc.i4.5 + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldc.i4.5 + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldc.i4.5 + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldc.i4.5 + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldc.i4.5 + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldc.i4.5 + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldc.i4.5 + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassRightShiftTest + + .method public hidebysig static void CustomClassBitAndTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassBitAndTest + + .method public hidebysig static void CustomClassBitOrTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassBitOrTest + + .method public hidebysig static void CustomClassBitXorTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004f: ldnull + IL_0050: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0055: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0062: ldnull + IL_0063: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0079: ldnull + IL_007a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008f: ldnull + IL_0090: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a6: ldnull + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00bc: ldnull + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d3: ldnull + IL_00d4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e9: ldnull + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0100: ldnull + IL_0101: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0116: ldnull + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomClassBitXorTest - .method public hidebysig instance int32 - PostIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomClassPostIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 399 (0x18f) .maxstack 3 - .locals init (int32 V_0) + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: conv.i2 - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: dup + IL_001d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: dup + IL_0036: stloc.0 + IL_0037: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: dup + IL_0050: stloc.0 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006b: dup + IL_006c: stloc.0 + IL_006d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0072: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0086: dup + IL_0087: stloc.0 + IL_0088: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a5: dup + IL_00a6: stloc.0 + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c3: dup + IL_00c4: stloc.0 + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e2: dup + IL_00e3: stloc.0 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0100: dup + IL_0101: stloc.0 + IL_0102: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_011f: dup + IL_0120: stloc.0 + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_013d: dup + IL_013e: stloc.0 + IL_013f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_015c: dup + IL_015d: stloc.0 + IL_015e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0163: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_017a: dup + IL_017b: stloc.0 + IL_017c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomClassPostIncTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + .method public hidebysig static void CustomClassPreIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 399 (0x18f) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: dup + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003a: dup + IL_003b: stloc.0 + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0054: dup + IL_0055: stloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0070: dup + IL_0071: stloc.0 + IL_0072: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0086: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008b: dup + IL_008c: stloc.0 + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: dup + IL_00ab: stloc.0 + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c3: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c8: dup + IL_00c9: stloc.0 + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: dup + IL_0106: stloc.0 + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_011f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0124: dup + IL_0125: stloc.0 + IL_0126: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0142: dup + IL_0143: stloc.0 + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_015c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0161: dup + IL_0162: stloc.0 + IL_0163: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_017a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017f: dup + IL_0180: stloc.0 + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomClassPreIncTest - .method public hidebysig instance void - IncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomClassPostDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 399 (0x18f) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: dup + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: dup + IL_001d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: dup + IL_0036: stloc.0 + IL_0037: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: dup + IL_0050: stloc.0 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006b: dup + IL_006c: stloc.0 + IL_006d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0072: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0086: dup + IL_0087: stloc.0 + IL_0088: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a5: dup + IL_00a6: stloc.0 + IL_00a7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c3: dup + IL_00c4: stloc.0 + IL_00c5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e2: dup + IL_00e3: stloc.0 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0100: dup + IL_0101: stloc.0 + IL_0102: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_011f: dup + IL_0120: stloc.0 + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_013d: dup + IL_013e: stloc.0 + IL_013f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_015c: dup + IL_015d: stloc.0 + IL_015e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0163: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_017a: dup + IL_017b: stloc.0 + IL_017c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomClassPostDecTest - .method public hidebysig instance void - DoubleStaticFieldShort() cil managed + .method public hidebysig static void CustomClassPreDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 399 (0x18f) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: dup + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003a: dup + IL_003b: stloc.0 + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0054: dup + IL_0055: stloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0070: dup + IL_0071: stloc.0 + IL_0072: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0086: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008b: dup + IL_008c: stloc.0 + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: dup + IL_00ab: stloc.0 + IL_00ac: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c3: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c8: dup + IL_00c9: stloc.0 + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0100: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: dup + IL_0106: stloc.0 + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_011f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0124: dup + IL_0125: stloc.0 + IL_0126: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0142: dup + IL_0143: stloc.0 + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_015c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0161: dup + IL_0162: stloc.0 + IL_0163: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_017a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017f: dup + IL_0180: stloc.0 + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomClassPreDecTest - .method public hidebysig instance int16 - DoubleStaticFieldAndReturnShort() cil managed + .method public hidebysig static void CustomStructAddTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int16 V_0) + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: conv.i2 - IL_0009: dup - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructAddTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + .method public hidebysig static void CustomStructSubtractTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructSubtractTest - .method public hidebysig instance int32 - PreIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructMultiplyTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int32 V_0) + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructMultiplyTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + .method public hidebysig static void CustomStructDivideTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructDivideTest - .method public hidebysig instance int32 - PostIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructModulusTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 403 (0x193) .maxstack 3 - .locals init (int32 V_0) + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructModulusTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + .method public hidebysig static void CustomStructLeftShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 291 (0x123) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldc.i4.5 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0016: ldc.i4.5 + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0029: ldc.i4.5 + IL_002a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_003b: ldc.i4.5 + IL_003c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004f: ldc.i4.5 + IL_0050: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0055: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0062: ldc.i4.5 + IL_0063: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0079: ldc.i4.5 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_007f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_008f: ldc.i4.5 + IL_0090: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a6: ldc.i4.5 + IL_00a7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00bc: ldc.i4.5 + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d3: ldc.i4.5 + IL_00d4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00d9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00e9: ldc.i4.5 + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0100: ldc.i4.5 + IL_0101: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0106: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0116: ldc.i4.5 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomStructLeftShiftTest - .method public hidebysig instance void - IncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructRightShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 291 (0x123) + .maxstack 3 IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: nop - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementStaticProperty + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldc.i4.5 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0016: ldc.i4.5 + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0029: ldc.i4.5 + IL_002a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_003b: ldc.i4.5 + IL_003c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: dup + IL_004a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004f: ldc.i4.5 + IL_0050: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0055: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_005a: ldarga.s s + IL_005c: dup + IL_005d: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0062: ldc.i4.5 + IL_0063: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0068: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006d: nop + IL_006e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0073: dup + IL_0074: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0079: ldc.i4.5 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_007f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_008f: ldc.i4.5 + IL_0090: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0095: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: nop + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: dup + IL_00a1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a6: ldc.i4.5 + IL_00a7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00b1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b6: dup + IL_00b7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00bc: ldc.i4.5 + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00c2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: nop + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00cd: dup + IL_00ce: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d3: ldc.i4.5 + IL_00d4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00d9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e3: dup + IL_00e4: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00e9: ldc.i4.5 + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ef: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: nop + IL_00f5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fa: dup + IL_00fb: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0100: ldc.i4.5 + IL_0101: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0106: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0110: dup + IL_0111: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0116: ldc.i4.5 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_011c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: ret + } // end of method CompoundAssignmentTest::CustomStructRightShiftTest - .method public hidebysig instance void - DoubleStaticProperty() cil managed + .method public hidebysig static void CustomStructBitAndTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: nop - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticProperty + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructBitAndTest - .method public hidebysig instance int32 - DoubleStaticPropertyAndReturn() cil managed + .method public hidebysig static void CustomStructBitOrTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int32 V_0) + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructBitOrTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + .method public hidebysig static void CustomStructBitXorTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 403 (0x193) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006f: ldloca.s V_0 + IL_0071: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0077: ldloc.0 + IL_0078: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0082: ldarga.s s + IL_0084: dup + IL_0085: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008a: ldloca.s V_0 + IL_008c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0092: ldloc.0 + IL_0093: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0098: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: nop + IL_009e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a3: dup + IL_00a4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a9: ldloca.s V_0 + IL_00ab: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b1: ldloc.0 + IL_00b2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bc: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c1: dup + IL_00c2: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c7: ldloca.s V_0 + IL_00c9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00cf: ldloc.0 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: nop + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloca.s V_0 + IL_00e8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ee: ldloc.0 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_0 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.0 + IL_010d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0112: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: nop + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_0 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.0 + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0131: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013b: dup + IL_013c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0141: ldloca.s V_0 + IL_0143: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0149: ldloc.0 + IL_014a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0154: nop + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0160: ldloca.s V_0 + IL_0162: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0168: ldloc.0 + IL_0169: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016e: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0173: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0178: dup + IL_0179: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017e: ldloca.s V_0 + IL_0180: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0186: ldloc.0 + IL_0187: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0191: nop + IL_0192: ret + } // end of method CompoundAssignmentTest::CustomStructBitXorTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PreIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPostIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 2 - .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + // Code size 399 (0x18f) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: dup - IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000f: nop - IL_0010: stloc.0 - IL_0011: br.s IL_0013 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: dup + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: dup + IL_001d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: dup + IL_0036: stloc.0 + IL_0037: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: dup + IL_0050: stloc.0 + IL_0051: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: stloc.0 + IL_006d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0072: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0086: dup + IL_0087: stloc.0 + IL_0088: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a5: dup + IL_00a6: stloc.0 + IL_00a7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c3: dup + IL_00c4: stloc.0 + IL_00c5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e2: dup + IL_00e3: stloc.0 + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0100: dup + IL_0101: stloc.0 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_011f: dup + IL_0120: stloc.0 + IL_0121: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0126: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_013d: dup + IL_013e: stloc.0 + IL_013f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015c: dup + IL_015d: stloc.0 + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0163: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017a: dup + IL_017b: stloc.0 + IL_017c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomStructPostIncTest - IL_0013: ldloc.0 - IL_0014: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + .method public hidebysig static void CustomStructPreIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 399 (0x18f) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: dup + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003a: dup + IL_003b: stloc.0 + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0054: dup + IL_0055: stloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0070: dup + IL_0071: stloc.0 + IL_0072: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0086: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008b: dup + IL_008c: stloc.0 + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00aa: dup + IL_00ab: stloc.0 + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c8: dup + IL_00c9: stloc.0 + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0100: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: dup + IL_0106: stloc.0 + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_011f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0124: dup + IL_0125: stloc.0 + IL_0126: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_013d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: dup + IL_0143: stloc.0 + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0161: dup + IL_0162: stloc.0 + IL_0163: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017f: dup + IL_0180: stloc.0 + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomStructPreIncTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PostIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPostDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) + // Code size 399 (0x18f) .maxstack 3 - .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: conv.i2 - IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000f: nop - IL_0010: stloc.0 - IL_0011: br.s IL_0013 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: dup + IL_001d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: dup + IL_0036: stloc.0 + IL_0037: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: dup + IL_0050: stloc.0 + IL_0051: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: stloc.0 + IL_006d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0072: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0086: dup + IL_0087: stloc.0 + IL_0088: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a5: dup + IL_00a6: stloc.0 + IL_00a7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c3: dup + IL_00c4: stloc.0 + IL_00c5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e2: dup + IL_00e3: stloc.0 + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0100: dup + IL_0101: stloc.0 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_011f: dup + IL_0120: stloc.0 + IL_0121: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0126: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_013d: dup + IL_013e: stloc.0 + IL_013f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015c: dup + IL_015d: stloc.0 + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0163: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017a: dup + IL_017b: stloc.0 + IL_017c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomStructPostDecTest - IL_0013: ldloc.0 - IL_0014: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + .method public hidebysig static void CustomStructPreDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 399 (0x18f) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: dup + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003a: dup + IL_003b: stloc.0 + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0054: dup + IL_0055: stloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: dup + IL_0066: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0070: dup + IL_0071: stloc.0 + IL_0072: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0077: ldloc.0 + IL_0078: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007d: nop + IL_007e: ldarga.s s + IL_0080: dup + IL_0081: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0086: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008b: dup + IL_008c: stloc.0 + IL_008d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: nop + IL_0093: ldloc.0 + IL_0094: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0099: nop + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00aa: dup + IL_00ab: stloc.0 + IL_00ac: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: nop + IL_00b8: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00bd: dup + IL_00be: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c8: dup + IL_00c9: stloc.0 + IL_00ca: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: nop + IL_00d0: ldloc.0 + IL_00d1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d6: nop + IL_00d7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00dc: dup + IL_00dd: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e7: dup + IL_00e8: stloc.0 + IL_00e9: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ee: ldloc.0 + IL_00ef: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f4: nop + IL_00f5: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fa: dup + IL_00fb: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0100: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: dup + IL_0106: stloc.0 + IL_0107: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010c: nop + IL_010d: ldloc.0 + IL_010e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0113: nop + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0119: dup + IL_011a: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_011f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0124: dup + IL_0125: stloc.0 + IL_0126: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012b: ldloc.0 + IL_012c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0131: nop + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0137: dup + IL_0138: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_013d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: dup + IL_0143: stloc.0 + IL_0144: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0149: nop + IL_014a: ldloc.0 + IL_014b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0150: nop + IL_0151: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0156: dup + IL_0157: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0161: dup + IL_0162: stloc.0 + IL_0163: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: nop + IL_016f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0174: dup + IL_0175: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_017a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017f: dup + IL_0180: stloc.0 + IL_0181: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0186: nop + IL_0187: ldloc.0 + IL_0188: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018d: nop + IL_018e: ret + } // end of method CompoundAssignmentTest::CustomStructPreDecTest - .method public hidebysig instance void - IncrementStaticPropertyShort() cil managed + .method public hidebysig static void AddOneToCustomClass(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& c) cil managed { - // Code size 16 (0x10) + // Code size 32 (0x20) .maxstack 8 IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: nop - IL_000f: ret - } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + IL_0001: ldarg.0 + IL_0002: dup + IL_0003: ldind.ref + IL_0004: ldc.i4.1 + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000a: stind.ref + IL_000b: ldarg.0 + IL_000c: ldind.ref + IL_000d: dup + IL_000e: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0013: ldc.i4.1 + IL_0014: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0019: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001e: nop + IL_001f: ret + } // end of method CompoundAssignmentTest::AddOneToCustomClass .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/Item GetItem(object obj) cil managed @@ -1960,27 +21445,22 @@ .method private hidebysig instance void Issue588(uint16 val) cil managed { - // Code size 33 (0x21) - .maxstack 4 - .locals init (uint16 V_0) + // Code size 29 (0x1d) + .maxstack 8 IL_0000: nop IL_0001: ldarg.0 IL_0002: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortDict - IL_0007: ldarg.0 - IL_0008: dup - IL_0009: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_000e: dup - IL_000f: stloc.0 - IL_0010: ldc.i4.1 - IL_0011: add - IL_0012: conv.u2 - IL_0013: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_0018: ldloc.0 - IL_0019: ldarg.1 - IL_001a: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, + IL_0007: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000c: dup + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.u2 + IL_0010: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0015: ldarg.1 + IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) - IL_001f: nop - IL_0020: ret + IL_001b: nop + IL_001c: ret } // end of method CompoundAssignmentTest::Issue588 .method private hidebysig instance void @@ -2029,6 +21509,58 @@ IL_0012: ret } // end of method CompoundAssignmentTest::.ctor + .property class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CompoundAssignmentTest::CustomClassProp + .property valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + .get valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + } // end of property CompoundAssignmentTest::CustomStructProp + .property uint8 ByteProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + .get uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + } // end of property CompoundAssignmentTest::ByteProp + .property int8 SbyteProp() + { + .get int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + } // end of property CompoundAssignmentTest::SbyteProp + .property int16 ShortProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + .get int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + } // end of property CompoundAssignmentTest::ShortProp + .property uint16 UshortProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + .get uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + } // end of property CompoundAssignmentTest::UshortProp + .property int32 IntProp() + { + .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + } // end of property CompoundAssignmentTest::IntProp + .property uint32 UintProp() + { + .get uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + } // end of property CompoundAssignmentTest::UintProp + .property int64 LongProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + .get int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + } // end of property CompoundAssignmentTest::LongProp + .property uint64 UlongProp() + { + .get uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + } // end of property CompoundAssignmentTest::UlongProp .property int32 StaticProperty() { .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() @@ -2046,4 +21578,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\CompoundAssignmentTest.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.il index 5b56d6f63..4f4b4d73d 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly eoamkle2 +.assembly CompoundAssignmentTest.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module eoamkle2.dll -// MVID: {61ABCA72-03C4-4AE8-9DF9-464B253BB877} +.module CompoundAssignmentTest.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x030A0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -150,8 +146,8 @@ .property instance int32 Property() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() } // end of property MutableClass::Property .property instance uint8 ByteProperty() { @@ -182,1391 +178,19520 @@ } // end of class Item - .field private int32 test1 - .field private int32[] array1 - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField - .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict - .field private uint16 ushortField - .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField - .field public static int32 StaticField - .field public static int16 StaticShortField - .field private static int32 'k__BackingField' - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - .method public hidebysig specialname static - int32 get_StaticProperty() cil managed + .class auto ansi nested public beforefieldinit CustomClass + extends [mscorlib]System.Object { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field private uint8 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticProperty - - .method public hidebysig specialname static - void set_StaticProperty(int32 'value') cil managed - { + .field private int8 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticProperty - - .method public hidebysig specialname static - valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - get_StaticShortProperty() cil managed - { + .field private int16 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticShortProperty - - .method public hidebysig specialname static - void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed - { + .field private uint16 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticShortProperty - - .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass - M() cil managed - { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() - IL_0005: ret - } // end of method CompoundAssignmentTest::M + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ByteProp - .method private hidebysig instance int32[0...,0...] - Array() cil managed - { - // Code size 2 (0x2) - .maxstack 8 - IL_0000: ldnull - IL_0001: ret - } // end of method CompoundAssignmentTest::Array + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ByteProp - .method private hidebysig instance int32* - GetPointer() cil managed - { - // Code size 3 (0x3) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: conv.u - IL_0002: ret - } // end of method CompoundAssignmentTest::GetPointer + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_SbyteProp - .method public hidebysig instance int32 - GetIndex() cil managed - { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: newobj instance void [mscorlib]System.Random::.ctor() - IL_0005: ldc.i4.0 - IL_0006: ldc.i4.s 100 - IL_0008: callvirt instance int32 [mscorlib]System.Random::Next(int32, - int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::GetIndex + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_SbyteProp - .method public hidebysig instance int32[] - GetArray() cil managed - { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0005: throw - } // end of method CompoundAssignmentTest::GetArray + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ShortProp - .method public hidebysig instance int32 - GetValue(int32 'value') cil managed - { - // Code size 2 (0x2) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ret - } // end of method CompoundAssignmentTest::GetValue + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ShortProp - .method public hidebysig instance bool - IsUpperCaseA(char a) cil managed - { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.s 65 - IL_0003: ceq - IL_0005: ret - } // end of method CompoundAssignmentTest::IsUpperCaseA + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UshortProp - .method public hidebysig instance void - Int32_Local_Add(int32 i) cil managed - { - // Code size 44 (0x2c) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.1 - IL_0002: add - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ldarg.1 - IL_0011: ldc.i4.1 - IL_0012: add - IL_0013: dup - IL_0014: starg.s i - IL_0016: call void [mscorlib]System.Console::WriteLine(int32) - IL_001b: ldarg.1 - IL_001c: ldc.i4.5 - IL_001d: add - IL_001e: starg.s i - IL_0020: ldarg.1 - IL_0021: ldc.i4.5 - IL_0022: add - IL_0023: dup - IL_0024: starg.s i - IL_0026: call void [mscorlib]System.Console::WriteLine(int32) - IL_002b: ret - } // end of method CompoundAssignmentTest::Int32_Local_Add + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UshortProp - .method public hidebysig instance void - Int32_Local_Sub(int32 i) cil managed - { - // Code size 44 (0x2c) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.1 - IL_0002: sub - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: sub - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ldarg.1 - IL_0011: ldc.i4.1 - IL_0012: sub - IL_0013: dup - IL_0014: starg.s i - IL_0016: call void [mscorlib]System.Console::WriteLine(int32) - IL_001b: ldarg.1 - IL_001c: ldc.i4.5 - IL_001d: sub - IL_001e: starg.s i - IL_0020: ldarg.1 - IL_0021: ldc.i4.5 - IL_0022: sub - IL_0023: dup - IL_0024: starg.s i - IL_0026: call void [mscorlib]System.Console::WriteLine(int32) - IL_002b: ret - } // end of method CompoundAssignmentTest::Int32_Local_Sub + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UlongProp + + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomStructProp + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Subtraction + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Multiply + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Division + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Modulus + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_LeftShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_RightShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_BitwiseAnd + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_BitwiseOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_ExclusiveOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Increment + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Decrement + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method CustomClass::.ctor + + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + } // end of property CustomClass::ByteProp + .property instance int8 SbyteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + } // end of property CustomClass::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + } // end of property CustomClass::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + } // end of property CustomClass::UshortProp + .property instance int32 IntProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + } // end of property CustomClass::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + } // end of property CustomClass::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + } // end of property CustomClass::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + } // end of property CustomClass::UlongProp + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + } // end of property CustomClass::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + } // end of property CustomClass::CustomStructProp + } // end of class CustomClass + + .class sequential ansi sealed nested public beforefieldinit CustomStruct + extends [mscorlib]System.ValueType + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_CustomClassProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UlongProp + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Addition + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Subtraction + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Multiply + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Division + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Modulus + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_LeftShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_RightShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_BitwiseAnd + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_BitwiseOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_ExclusiveOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Increment + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Decrement + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct::CustomClassProp + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ByteProp() + } // end of property CustomStruct::ByteProp + .property instance int8 SbyteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_SbyteProp(int8) + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_SbyteProp() + } // end of property CustomStruct::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ShortProp(int16) + } // end of property CustomStruct::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UshortProp(uint16) + } // end of property CustomStruct::UshortProp + .property instance int32 IntProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_IntProp(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_IntProp() + } // end of property CustomStruct::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UintProp(uint32) + } // end of property CustomStruct::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_LongProp() + } // end of property CustomStruct::LongProp + .property instance uint64 UlongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UlongProp(uint64) + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UlongProp() + } // end of property CustomStruct::UlongProp + } // end of class CustomStruct + + .class sequential ansi sealed nested public beforefieldinit CustomStruct2 + extends [mscorlib]System.ValueType + { + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomStructProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UlongProp + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct2::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomStruct2::CustomStructProp + .property instance uint8 ByteProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + } // end of property CustomStruct2::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + } // end of property CustomStruct2::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + } // end of property CustomStruct2::ShortProp + .property instance uint16 UshortProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + } // end of property CustomStruct2::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + } // end of property CustomStruct2::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + } // end of property CustomStruct2::UintProp + .property instance int64 LongProp() + { + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + } // end of property CustomStruct2::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + } // end of property CustomStruct2::UlongProp + } // end of class CustomStruct2 + + .field private int32 test1 + .field private int32[] array1 + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField + .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField + .field public static int32 StaticField + .field public static int16 StaticShortField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass customClassField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct customStructField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 otherCustomStructField + .field private static uint8 byteField + .field private static int8 sbyteField + .field private static int16 shortField + .field private static uint16 ushortField + .field private static int32 intField + .field private static uint32 uintField + .field private static int64 longField + .field private static uint64 ulongField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method private hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomClassProp + + .method private hidebysig specialname static + void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomClassProp + + .method private hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomStructProp + + .method private hidebysig specialname static + void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomStructProp + + .method private hidebysig specialname static + uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ByteProp + + .method private hidebysig specialname static + void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ByteProp + + .method private hidebysig specialname static + int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_SbyteProp + + .method private hidebysig specialname static + void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_SbyteProp + + .method private hidebysig specialname static + int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ShortProp + + .method private hidebysig specialname static + void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ShortProp + + .method private hidebysig specialname static + uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UshortProp + + .method private hidebysig specialname static + void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UshortProp + + .method private hidebysig specialname static + int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_IntProp + + .method private hidebysig specialname static + void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_IntProp + + .method private hidebysig specialname static + uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UintProp + + .method private hidebysig specialname static + void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UintProp + + .method private hidebysig specialname static + int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_LongProp + + .method private hidebysig specialname static + void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_LongProp + + .method private hidebysig specialname static + uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UlongProp + + .method private hidebysig specialname static + void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UlongProp + + .method public hidebysig specialname static + int32 get_StaticProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticProperty + + .method public hidebysig specialname static + void set_StaticProperty(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticProperty + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + get_StaticShortProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticShortProperty + + .method public hidebysig specialname static + void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticShortProperty + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + GetClass() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetClass + + .method private hidebysig static void X(!!T result) cil managed + { + // Code size 1 (0x1) + .maxstack 8 + IL_0000: ret + } // end of method CompoundAssignmentTest::X + + .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass + M() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() + IL_0005: ret + } // end of method CompoundAssignmentTest::M + + .method private hidebysig instance int32[0...,0...] + Array() cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: ldnull + IL_0001: ret + } // end of method CompoundAssignmentTest::Array + + .method private hidebysig instance int32* + GetPointer() cil managed + { + // Code size 3 (0x3) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: conv.u + IL_0002: ret + } // end of method CompoundAssignmentTest::GetPointer + + .method public hidebysig instance int32 + GetIndex() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.Random::.ctor() + IL_0005: ldc.i4.0 + IL_0006: ldc.i4.s 100 + IL_0008: callvirt instance int32 [mscorlib]System.Random::Next(int32, + int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::GetIndex + + .method public hidebysig instance int32[] + GetArray() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetArray + + .method public hidebysig instance int32 + GetValue(int32 'value') cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ret + } // end of method CompoundAssignmentTest::GetValue + + .method public hidebysig instance bool + IsUpperCaseA(char a) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.s 65 + IL_0003: ceq + IL_0005: ret + } // end of method CompoundAssignmentTest::IsUpperCaseA + + .method public hidebysig instance void + Int32_Local_Add(int32 i) cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.1 + IL_0002: add + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ldarg.1 + IL_0011: ldc.i4.1 + IL_0012: add + IL_0013: dup + IL_0014: starg.s i + IL_0016: call void [mscorlib]System.Console::WriteLine(int32) + IL_001b: ldarg.1 + IL_001c: ldc.i4.5 + IL_001d: add + IL_001e: starg.s i + IL_0020: ldarg.1 + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: dup + IL_0024: starg.s i + IL_0026: call void [mscorlib]System.Console::WriteLine(int32) + IL_002b: ret + } // end of method CompoundAssignmentTest::Int32_Local_Add + + .method public hidebysig instance void + Int32_Local_Sub(int32 i) cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.1 + IL_0002: sub + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ldarg.1 + IL_0011: ldc.i4.1 + IL_0012: sub + IL_0013: dup + IL_0014: starg.s i + IL_0016: call void [mscorlib]System.Console::WriteLine(int32) + IL_001b: ldarg.1 + IL_001c: ldc.i4.5 + IL_001d: sub + IL_001e: starg.s i + IL_0020: ldarg.1 + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: dup + IL_0024: starg.s i + IL_0026: call void [mscorlib]System.Console::WriteLine(int32) + IL_002b: ret + } // end of method CompoundAssignmentTest::Int32_Local_Sub + + .method public hidebysig instance void + Int32_Local_Mul(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: mul + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Mul + + .method public hidebysig instance void + Int32_Local_Div(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: div + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Div + + .method public hidebysig instance void + Int32_Local_Rem(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: rem + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Rem + + .method public hidebysig instance void + Int32_Local_BitAnd(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: and + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + + .method public hidebysig instance void + Int32_Local_BitOr(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: or + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitOr + + .method public hidebysig instance void + Int32_Local_BitXor(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: xor + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitXor + + .method public hidebysig instance void + Int32_Local_ShiftLeft(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: shl + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + + .method public hidebysig instance void + Int32_Local_ShiftRight(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: shr + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + + .method public hidebysig instance void + IntegerWithInline(int32 i) cil managed + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: add + IL_0003: dup + IL_0004: starg.s i + IL_0006: call void [mscorlib]System.Console::WriteLine(int32) + IL_000b: ldarg.1 + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: ret + } // end of method CompoundAssignmentTest::IntegerWithInline + + .method public hidebysig instance void + IntegerField(int32 i) cil managed + { + // Code size 67 (0x43) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0007: ldarg.1 + IL_0008: add + IL_0009: dup + IL_000a: stloc.0 + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0010: ldloc.0 + IL_0011: call void [mscorlib]System.Console::WriteLine(int32) + IL_0016: ldarg.0 + IL_0017: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_001c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0021: ldarg.0 + IL_0022: dup + IL_0023: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0028: ldarg.1 + IL_0029: sub + IL_002a: dup + IL_002b: stloc.1 + IL_002c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0031: ldloc.1 + IL_0032: call void [mscorlib]System.Console::WriteLine(int32) + IL_0037: ldarg.0 + IL_0038: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_003d: call void [mscorlib]System.Console::WriteLine(int32) + IL_0042: ret + } // end of method CompoundAssignmentTest::IntegerField + + .method public hidebysig instance void + Array(int32 i) cil managed + { + // Code size 71 (0x47) + .maxstack 4 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0006: ldarg.1 + IL_0007: ldelema [mscorlib]System.Int32 + IL_000c: dup + IL_000d: ldobj [mscorlib]System.Int32 + IL_0012: ldarg.1 + IL_0013: add + IL_0014: dup + IL_0015: stloc.0 + IL_0016: stobj [mscorlib]System.Int32 + IL_001b: ldloc.0 + IL_001c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0021: ldarg.0 + IL_0022: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0027: ldarg.1 + IL_0028: ldc.i4.2 + IL_0029: mul + IL_002a: ldelema [mscorlib]System.Int32 + IL_002f: dup + IL_0030: ldobj [mscorlib]System.Int32 + IL_0035: ldarg.1 + IL_0036: ldc.i4.2 + IL_0037: mul + IL_0038: add + IL_0039: dup + IL_003a: stloc.1 + IL_003b: stobj [mscorlib]System.Int32 + IL_0040: ldloc.1 + IL_0041: call void [mscorlib]System.Console::WriteLine(int32) + IL_0046: ret + } // end of method CompoundAssignmentTest::Array + + .method public hidebysig instance int32 + ArrayUsageWithMethods() cil managed + { + // Code size 34 (0x22) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() + IL_0006: ldarg.0 + IL_0007: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() + IL_000c: ldelema [mscorlib]System.Int32 + IL_0011: dup + IL_0012: ldobj [mscorlib]System.Int32 + IL_0017: dup + IL_0018: stloc.0 + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: stobj [mscorlib]System.Int32 + IL_0020: ldloc.0 + IL_0021: ret + } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + + .method public hidebysig instance void + NestedField() cil managed + { + // Code size 87 (0x57) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: ldarg.0 + IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0006: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex + IL_000b: brfalse.s IL_0056 + + IL_000d: ldarg.0 + IL_000e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0013: dup + IL_0014: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0019: ldc.i4.2 + IL_001a: mul + IL_001b: dup + IL_001c: stloc.0 + IL_001d: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0022: ldloc.0 + IL_0023: call void [mscorlib]System.Console::WriteLine(int32) + IL_0028: ldarg.0 + IL_0029: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_002e: dup + IL_002f: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0034: ldc.i4.1 + IL_0035: add + IL_0036: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_003b: ldarg.0 + IL_003c: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0041: dup + IL_0042: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0047: dup + IL_0048: stloc.1 + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0050: ldloc.1 + IL_0051: call void [mscorlib]System.Console::WriteLine(int32) + IL_0056: ret + } // end of method CompoundAssignmentTest::NestedField + + .method public hidebysig instance void + Enum() cil managed + { + // Code size 58 (0x3a) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: dup + IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0007: ldc.i4.2 + IL_0008: or + IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_000e: ldarg.0 + IL_000f: dup + IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0015: ldc.i4.s -5 + IL_0017: and + IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_001d: ldarg.0 + IL_001e: dup + IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0024: ldc.i4.2 + IL_0025: add + IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_002b: ldarg.0 + IL_002c: dup + IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0032: ldc.i4.3 + IL_0033: sub + IL_0034: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0039: ret + } // end of method CompoundAssignmentTest::Enum + + .method public hidebysig instance void + ShortEnumTest() cil managed + { + // Code size 61 (0x3d) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: dup + IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0007: ldc.i4.2 + IL_0008: or + IL_0009: conv.i2 + IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_000f: ldarg.0 + IL_0010: dup + IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0016: ldc.i4.4 + IL_0017: and + IL_0018: conv.i2 + IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_001e: ldarg.0 + IL_001f: dup + IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0025: ldc.i4.2 + IL_0026: add + IL_0027: conv.i2 + IL_0028: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_002d: ldarg.0 + IL_002e: dup + IL_002f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0034: ldc.i4.3 + IL_0035: sub + IL_0036: conv.i2 + IL_0037: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_003c: ret + } // end of method CompoundAssignmentTest::ShortEnumTest + + .method public hidebysig instance int32 + PreIncrementInAddition(int32 i, + int32 j) cil managed + { + // Code size 9 (0x9) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldc.i4.1 + IL_0003: add + IL_0004: dup + IL_0005: starg.s j + IL_0007: add + IL_0008: ret + } // end of method CompoundAssignmentTest::PreIncrementInAddition + + .method public hidebysig instance int32 + PreIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int32 + IL_000d: ldc.i4.1 + IL_000e: sub + IL_000f: dup + IL_0010: stloc.0 + IL_0011: stobj [mscorlib]System.Int32 + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElement + + .method public hidebysig instance int32 + PostIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int32 + IL_000d: dup + IL_000e: stloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: stobj [mscorlib]System.Int32 + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElement + + .method public hidebysig instance void + IncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int32 + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: stobj [mscorlib]System.Int32 + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementArrayElement + + .method public hidebysig instance void + DoubleArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int32 + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: stobj [mscorlib]System.Int32 + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleArrayElement + + .method public hidebysig instance int32 + DoubleArrayElementAndReturn(int32[] 'array', + int32 pos) cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int32 + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: dup + IL_0010: stloc.0 + IL_0011: stobj [mscorlib]System.Int32 + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + + .method public hidebysig instance int32 + PreIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int16 + IL_000d: ldc.i4.1 + IL_000e: sub + IL_000f: conv.i2 + IL_0010: dup + IL_0011: stloc.0 + IL_0012: stobj [mscorlib]System.Int16 + IL_0017: ldloc.0 + IL_0018: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + + .method public hidebysig instance int32 + PostIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int16 + IL_000d: dup + IL_000e: stloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.i2 + IL_0012: stobj [mscorlib]System.Int16 + IL_0017: ldloc.0 + IL_0018: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + + .method public hidebysig instance void + IncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int16 + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.i2 + IL_0010: stobj [mscorlib]System.Int16 + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementArrayElementShort + + .method public hidebysig instance void + DoubleArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int16 + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.i2 + IL_0010: stobj [mscorlib]System.Int16 + IL_0015: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShort + + .method public hidebysig instance int16 + DoubleArrayElementShortAndReturn(int16[] 'array', + int32 pos) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldobj [mscorlib]System.Int16 + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.i2 + IL_0010: dup + IL_0011: stloc.0 + IL_0012: stobj [mscorlib]System.Int16 + IL_0017: ldloc.0 + IL_0018: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: dup + IL_000f: stloc.0 + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField + + .method public hidebysig instance int32 + PostIncrementInstanceField() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: dup + IL_000d: stloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField + + .method public hidebysig instance void + IncrementInstanceField() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0013: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField + + .method public hidebysig instance void + DoubleInstanceField() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleInstanceField + + .method public hidebysig instance int32 + DoubleInstanceFieldAndReturn() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: dup + IL_000f: stloc.0 + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 18 (0x12) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: dup + IL_000a: stloc.0 + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0010: ldloc.0 + IL_0011: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + + .method public hidebysig instance int32 + PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 18 (0x12) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: dup + IL_0008: stloc.0 + IL_0009: ldc.i4.1 + IL_000a: add + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0010: ldloc.0 + IL_0011: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + + .method public hidebysig instance void + IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField2 + + .method public hidebysig instance int32 + PreIncrementInstanceFieldShort() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.i2 + IL_000f: dup + IL_0010: stloc.0 + IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + + .method public hidebysig instance int32 + PostIncrementInstanceFieldShort() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: dup + IL_000d: stloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.i2 + IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + + .method public hidebysig instance void + IncrementInstanceFieldShort() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.i2 + IL_000f: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + + .method public hidebysig instance int32 + PreIncrementInstanceProperty() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: dup + IL_000f: stloc.0 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + + .method public hidebysig instance int32 + PostIncrementInstanceProperty() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: dup + IL_000d: stloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + + .method public hidebysig instance void + IncrementInstanceProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0013: ret + } // end of method CompoundAssignmentTest::IncrementInstanceProperty + + .method public hidebysig instance void + DoubleInstanceProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleInstanceProperty + + .method public hidebysig instance int32 + DoubleInstancePropertyAndReturn() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: dup + IL_000f: stloc.0 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + + .method public hidebysig instance int32 + PreIncrementInstancePropertyByte() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.u1 + IL_000f: dup + IL_0010: stloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + + .method public hidebysig instance int32 + PostIncrementInstancePropertyByte() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: dup + IL_000d: stloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.u1 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + + .method public hidebysig instance void + IncrementInstancePropertyByte() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.u1 + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + + .method public hidebysig instance void + DoubleInstancePropertyByte() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: conv.u1 + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + + .method public hidebysig instance int32 + DoubleInstancePropertyByteAndReturn() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: conv.u1 + IL_000f: dup + IL_0010: stloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticField + + .method public hidebysig instance int32 + PostIncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticField + + .method public hidebysig instance void + IncrementStaticField() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000c: ret + } // end of method CompoundAssignmentTest::IncrementStaticField + + .method public hidebysig instance void + DoubleStaticField() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000c: ret + } // end of method CompoundAssignmentTest::DoubleStaticField + + .method public hidebysig instance int32 + DoubleStaticFieldAndReturn() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + + .method public hidebysig instance int32 + PostIncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + + .method public hidebysig instance void + IncrementStaticFieldShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + + .method public hidebysig instance void + DoubleStaticFieldShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + + .method public hidebysig instance int16 + DoubleStaticFieldAndReturnShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + + .method public hidebysig instance int32 + PreIncrementStaticProperty() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + + .method public hidebysig instance int32 + PostIncrementStaticProperty() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + + .method public hidebysig instance void + IncrementStaticProperty() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000c: ret + } // end of method CompoundAssignmentTest::IncrementStaticProperty + + .method public hidebysig instance void + DoubleStaticProperty() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000c: ret + } // end of method CompoundAssignmentTest::DoubleStaticProperty + + .method public hidebysig instance int32 + DoubleStaticPropertyAndReturn() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: dup + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PreIncrementStaticPropertyShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PostIncrementStaticPropertyShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort .method public hidebysig instance void - Int32_Local_Mul(int32 i) cil managed + IncrementStaticPropertyShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + + .method public hidebysig static void ByteAddTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: add + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: add + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: add + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: add + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteAddTest + + .method public hidebysig static void ByteSubtractTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: sub + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: sub + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: sub + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: sub + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteSubtractTest + + .method public hidebysig static void ByteMultiplyTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: mul + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: mul + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: mul + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: mul + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteMultiplyTest + + .method public hidebysig static void ByteDivideTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: div + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: div + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: div + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: div + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: div + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: div + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: div + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteDivideTest + + .method public hidebysig static void ByteModulusTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: rem + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: rem + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: rem + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: rem + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: rem + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: rem + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: rem + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteModulusTest + + .method public hidebysig static void ByteLeftShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: shl + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: shl + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: shl + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: shl + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteLeftShiftTest + + .method public hidebysig static void ByteRightShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: shr + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: shr + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: shr + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: shr + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteRightShiftTest + + .method public hidebysig static void ByteBitAndTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: and + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: and + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: and + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: and + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteBitAndTest + + .method public hidebysig static void ByteBitOrTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: or + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: or + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: or + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: or + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteBitOrTest + + .method public hidebysig static void ByteBitXorTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: conv.u1 + IL_0043: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0063: ldc.i4.5 + IL_0064: xor + IL_0065: conv.u1 + IL_0066: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0076: ldc.i4.5 + IL_0077: xor + IL_0078: conv.u1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0089: ldc.i4.5 + IL_008a: xor + IL_008b: conv.u1 + IL_008c: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009c: ldc.i4.5 + IL_009d: xor + IL_009e: conv.u1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: conv.u1 + IL_00d8: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: conv.u1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ByteBitXorTest + + .method public hidebysig static void BytePostIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint8 V_0, + uint8 V_1, + uint8 V_2, + uint8 V_3, + uint8 V_4, + uint8 V_5, + uint8 V_6, + uint8 V_7, + uint8 V_8, + uint8 V_9, + uint8 V_10, + uint8 V_11) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.u1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.u1 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.u1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: add + IL_0060: conv.u1 + IL_0061: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: conv.u1 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: conv.u1 + IL_0095: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: add + IL_00b1: conv.u1 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: conv.u1 + IL_00cf: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: add + IL_00eb: conv.u1 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: add + IL_0108: conv.u1 + IL_0109: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.u1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.u1 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: add + IL_015f: conv.u1 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::BytePostIncTest + + .method public hidebysig static void BytePreIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint8 V_0, + uint8 V_1, + uint8 V_2, + uint8 V_3, + uint8 V_4, + uint8 V_5, + uint8 V_6, + uint8 V_7, + uint8 V_8, + uint8 V_9, + uint8 V_10, + uint8 V_11) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.u1 + IL_0008: dup + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.u1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.u1 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.u1 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005c: ldc.i4.1 + IL_005d: add + IL_005e: conv.u1 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: conv.u1 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008f: ldc.i4.1 + IL_0090: add + IL_0091: conv.u1 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ac: ldc.i4.1 + IL_00ad: add + IL_00ae: conv.u1 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c9: ldc.i4.1 + IL_00ca: add + IL_00cb: conv.u1 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e6: ldc.i4.1 + IL_00e7: add + IL_00e8: conv.u1 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: conv.u1 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0120: ldc.i4.1 + IL_0121: add + IL_0122: conv.u1 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013d: ldc.i4.1 + IL_013e: add + IL_013f: conv.u1 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.u1 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::BytePreIncTest + + .method public hidebysig static void BytePostDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint8 V_0, + uint8 V_1, + uint8 V_2, + uint8 V_3, + uint8 V_4, + uint8 V_5, + uint8 V_6, + uint8 V_7, + uint8 V_8, + uint8 V_9, + uint8 V_10, + uint8 V_11) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.u1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.u1 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.u1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: conv.u1 + IL_0061: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: conv.u1 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: conv.u1 + IL_0095: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: sub + IL_00b1: conv.u1 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: conv.u1 + IL_00cf: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: sub + IL_00eb: conv.u1 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: sub + IL_0108: conv.u1 + IL_0109: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.u1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.u1 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: sub + IL_015f: conv.u1 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::BytePostDecTest + + .method public hidebysig static void BytePreDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint8 V_0, + uint8 V_1, + uint8 V_2, + uint8 V_3, + uint8 V_4, + uint8 V_5, + uint8 V_6, + uint8 V_7, + uint8 V_8, + uint8 V_9, + uint8 V_10, + uint8 V_11) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.u1 + IL_0008: dup + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.u1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.u1 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.u1 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005c: ldc.i4.1 + IL_005d: sub + IL_005e: conv.u1 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: conv.u1 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008f: ldc.i4.1 + IL_0090: sub + IL_0091: conv.u1 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00ac: ldc.i4.1 + IL_00ad: sub + IL_00ae: conv.u1 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c9: ldc.i4.1 + IL_00ca: sub + IL_00cb: conv.u1 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e6: ldc.i4.1 + IL_00e7: sub + IL_00e8: conv.u1 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: conv.u1 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0120: ldc.i4.1 + IL_0121: sub + IL_0122: conv.u1 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013d: ldc.i4.1 + IL_013e: sub + IL_013f: conv.u1 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.u1 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::BytePreDecTest + + .method public hidebysig static void SbyteAddTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: add + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: add + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: add + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: add + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteAddTest + + .method public hidebysig static void SbyteSubtractTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: sub + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: sub + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: sub + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: sub + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteSubtractTest + + .method public hidebysig static void SbyteMultiplyTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: mul + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: mul + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: mul + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: mul + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteMultiplyTest + + .method public hidebysig static void SbyteDivideTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: div + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: div + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: div + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: div + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: div + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: div + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: div + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteDivideTest + + .method public hidebysig static void SbyteModulusTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: rem + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: rem + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: rem + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: rem + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: rem + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: rem + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: rem + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteModulusTest + + .method public hidebysig static void SbyteLeftShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: shl + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: shl + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: shl + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: shl + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteLeftShiftTest + + .method public hidebysig static void SbyteRightShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: shr + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: shr + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: shr + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: shr + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteRightShiftTest + + .method public hidebysig static void SbyteBitAndTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: and + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: and + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: and + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: and + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteBitAndTest + + .method public hidebysig static void SbyteBitOrTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: or + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: or + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: or + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: or + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteBitOrTest + + .method public hidebysig static void SbyteBitXorTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: conv.i1 + IL_0043: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0063: ldc.i4.5 + IL_0064: xor + IL_0065: conv.i1 + IL_0066: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0076: ldc.i4.5 + IL_0077: xor + IL_0078: conv.i1 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0089: ldc.i4.5 + IL_008a: xor + IL_008b: conv.i1 + IL_008c: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009c: ldc.i4.5 + IL_009d: xor + IL_009e: conv.i1 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: conv.i1 + IL_00d8: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: conv.i1 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f0: ret + } // end of method CompoundAssignmentTest::SbyteBitXorTest + + .method public hidebysig static void SbytePostIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int8 V_0, + int8 V_1, + int8 V_2, + int8 V_3, + int8 V_4, + int8 V_5, + int8 V_6, + int8 V_7, + int8 V_8, + int8 V_9, + int8 V_10, + int8 V_11) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.i1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.i1 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.i1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: add + IL_0060: conv.i1 + IL_0061: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: conv.i1 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: conv.i1 + IL_0095: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: add + IL_00b1: conv.i1 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: conv.i1 + IL_00cf: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: add + IL_00eb: conv.i1 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: add + IL_0108: conv.i1 + IL_0109: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.i1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.i1 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: add + IL_015f: conv.i1 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::SbytePostIncTest + + .method public hidebysig static void SbytePreIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int8 V_0, + int8 V_1, + int8 V_2, + int8 V_3, + int8 V_4, + int8 V_5, + int8 V_6, + int8 V_7, + int8 V_8, + int8 V_9, + int8 V_10, + int8 V_11) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i1 + IL_0008: dup + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.i1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.i1 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.i1 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005c: ldc.i4.1 + IL_005d: add + IL_005e: conv.i1 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: conv.i1 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008f: ldc.i4.1 + IL_0090: add + IL_0091: conv.i1 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ac: ldc.i4.1 + IL_00ad: add + IL_00ae: conv.i1 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c9: ldc.i4.1 + IL_00ca: add + IL_00cb: conv.i1 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e6: ldc.i4.1 + IL_00e7: add + IL_00e8: conv.i1 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: conv.i1 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0120: ldc.i4.1 + IL_0121: add + IL_0122: conv.i1 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013d: ldc.i4.1 + IL_013e: add + IL_013f: conv.i1 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.i1 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::SbytePreIncTest + + .method public hidebysig static void SbytePostDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int8 V_0, + int8 V_1, + int8 V_2, + int8 V_3, + int8 V_4, + int8 V_5, + int8 V_6, + int8 V_7, + int8 V_8, + int8 V_9, + int8 V_10, + int8 V_11) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.i1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.i1 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.i1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: conv.i1 + IL_0061: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: conv.i1 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: conv.i1 + IL_0095: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: sub + IL_00b1: conv.i1 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: conv.i1 + IL_00cf: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: sub + IL_00eb: conv.i1 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: sub + IL_0108: conv.i1 + IL_0109: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.i1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.i1 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: sub + IL_015f: conv.i1 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::SbytePostDecTest + + .method public hidebysig static void SbytePreDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int8 V_0, + int8 V_1, + int8 V_2, + int8 V_3, + int8 V_4, + int8 V_5, + int8 V_6, + int8 V_7, + int8 V_8, + int8 V_9, + int8 V_10, + int8 V_11) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.i1 + IL_0008: dup + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.i1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.i1 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.i1 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005c: ldc.i4.1 + IL_005d: sub + IL_005e: conv.i1 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: conv.i1 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008f: ldc.i4.1 + IL_0090: sub + IL_0091: conv.i1 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00ac: ldc.i4.1 + IL_00ad: sub + IL_00ae: conv.i1 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c9: ldc.i4.1 + IL_00ca: sub + IL_00cb: conv.i1 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e6: ldc.i4.1 + IL_00e7: sub + IL_00e8: conv.i1 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: conv.i1 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0120: ldc.i4.1 + IL_0121: sub + IL_0122: conv.i1 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013d: ldc.i4.1 + IL_013e: sub + IL_013f: conv.i1 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.i1 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::SbytePreDecTest + + .method public hidebysig static void ShortAddTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: add + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: add + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: add + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: add + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortAddTest + + .method public hidebysig static void ShortSubtractTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: sub + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: sub + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: sub + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: sub + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortSubtractTest + + .method public hidebysig static void ShortMultiplyTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: mul + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: mul + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: mul + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: mul + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortMultiplyTest + + .method public hidebysig static void ShortDivideTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: div + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: div + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: div + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: div + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: div + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: div + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: div + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortDivideTest + + .method public hidebysig static void ShortModulusTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: rem + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: rem + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: rem + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: rem + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: rem + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: rem + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: rem + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortModulusTest + + .method public hidebysig static void ShortLeftShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: shl + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: shl + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: shl + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: shl + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortLeftShiftTest + + .method public hidebysig static void ShortRightShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: shr + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: shr + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: shr + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: shr + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortRightShiftTest + + .method public hidebysig static void ShortBitAndTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: and + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: and + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: and + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: and + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortBitAndTest + + .method public hidebysig static void ShortBitOrTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: or + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: or + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: or + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: or + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortBitOrTest + + .method public hidebysig static void ShortBitXorTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: conv.i2 + IL_0043: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0063: ldc.i4.5 + IL_0064: xor + IL_0065: conv.i2 + IL_0066: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0076: ldc.i4.5 + IL_0077: xor + IL_0078: conv.i2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0089: ldc.i4.5 + IL_008a: xor + IL_008b: conv.i2 + IL_008c: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009c: ldc.i4.5 + IL_009d: xor + IL_009e: conv.i2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: conv.i2 + IL_00d8: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: conv.i2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::ShortBitXorTest + + .method public hidebysig static void ShortPostIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1, + int16 V_2, + int16 V_3, + int16 V_4, + int16 V_5, + int16 V_6, + int16 V_7, + int16 V_8, + int16 V_9, + int16 V_10, + int16 V_11) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.i2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.i2 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.i2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: add + IL_0060: conv.i2 + IL_0061: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: conv.i2 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: conv.i2 + IL_0095: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: add + IL_00b1: conv.i2 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: conv.i2 + IL_00cf: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: add + IL_00eb: conv.i2 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: add + IL_0108: conv.i2 + IL_0109: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.i2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.i2 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: add + IL_015f: conv.i2 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::ShortPostIncTest + + .method public hidebysig static void ShortPreIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1, + int16 V_2, + int16 V_3, + int16 V_4, + int16 V_5, + int16 V_6, + int16 V_7, + int16 V_8, + int16 V_9, + int16 V_10, + int16 V_11) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.i2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.i2 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.i2 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005c: ldc.i4.1 + IL_005d: add + IL_005e: conv.i2 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: conv.i2 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008f: ldc.i4.1 + IL_0090: add + IL_0091: conv.i2 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ac: ldc.i4.1 + IL_00ad: add + IL_00ae: conv.i2 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c9: ldc.i4.1 + IL_00ca: add + IL_00cb: conv.i2 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e6: ldc.i4.1 + IL_00e7: add + IL_00e8: conv.i2 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: conv.i2 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0120: ldc.i4.1 + IL_0121: add + IL_0122: conv.i2 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013d: ldc.i4.1 + IL_013e: add + IL_013f: conv.i2 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.i2 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::ShortPreIncTest + + .method public hidebysig static void ShortPostDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1, + int16 V_2, + int16 V_3, + int16 V_4, + int16 V_5, + int16 V_6, + int16 V_7, + int16 V_8, + int16 V_9, + int16 V_10, + int16 V_11) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.i2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.i2 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.i2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: conv.i2 + IL_0061: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: conv.i2 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: conv.i2 + IL_0095: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: sub + IL_00b1: conv.i2 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: conv.i2 + IL_00cf: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: sub + IL_00eb: conv.i2 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: sub + IL_0108: conv.i2 + IL_0109: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.i2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.i2 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: sub + IL_015f: conv.i2 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::ShortPostDecTest + + .method public hidebysig static void ShortPreDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1, + int16 V_2, + int16 V_3, + int16 V_4, + int16 V_5, + int16 V_6, + int16 V_7, + int16 V_8, + int16 V_9, + int16 V_10, + int16 V_11) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.i2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.i2 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.i2 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005c: ldc.i4.1 + IL_005d: sub + IL_005e: conv.i2 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: conv.i2 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008f: ldc.i4.1 + IL_0090: sub + IL_0091: conv.i2 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00ac: ldc.i4.1 + IL_00ad: sub + IL_00ae: conv.i2 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c9: ldc.i4.1 + IL_00ca: sub + IL_00cb: conv.i2 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e6: ldc.i4.1 + IL_00e7: sub + IL_00e8: conv.i2 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: conv.i2 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0120: ldc.i4.1 + IL_0121: sub + IL_0122: conv.i2 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013d: ldc.i4.1 + IL_013e: sub + IL_013f: conv.i2 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.i2 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::ShortPreDecTest + + .method public hidebysig static void UshortAddTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: add + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: add + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: add + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: add + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortAddTest + + .method public hidebysig static void UshortSubtractTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: sub + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: sub + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: sub + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: sub + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortSubtractTest + + .method public hidebysig static void UshortMultiplyTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: mul + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: mul + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: mul + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: mul + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortMultiplyTest + + .method public hidebysig static void UshortDivideTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: div + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: div + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: div + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: div + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: div + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: div + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: div + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortDivideTest + + .method public hidebysig static void UshortModulusTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: rem + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: rem + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: rem + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: rem + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: rem + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: rem + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: rem + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortModulusTest + + .method public hidebysig static void UshortLeftShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: shl + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: shl + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: shl + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: shl + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortLeftShiftTest + + .method public hidebysig static void UshortRightShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: shr + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: shr + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: shr + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: shr + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortRightShiftTest + + .method public hidebysig static void UshortBitAndTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: and + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: and + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: and + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: and + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortBitAndTest + + .method public hidebysig static void UshortBitOrTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: or + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: or + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: or + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: or + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortBitOrTest + + .method public hidebysig static void UshortBitXorTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: conv.u2 + IL_0043: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0063: ldc.i4.5 + IL_0064: xor + IL_0065: conv.u2 + IL_0066: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0076: ldc.i4.5 + IL_0077: xor + IL_0078: conv.u2 + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0089: ldc.i4.5 + IL_008a: xor + IL_008b: conv.u2 + IL_008c: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009c: ldc.i4.5 + IL_009d: xor + IL_009e: conv.u2 + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: conv.u2 + IL_00d8: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: conv.u2 + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UshortBitXorTest + + .method public hidebysig static void UshortPostIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint16 V_0, + uint16 V_1, + uint16 V_2, + uint16 V_3, + uint16 V_4, + uint16 V_5, + uint16 V_6, + uint16 V_7, + uint16 V_8, + uint16 V_9, + uint16 V_10, + uint16 V_11) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.u2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.u2 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.u2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: add + IL_0060: conv.u2 + IL_0061: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: conv.u2 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: conv.u2 + IL_0095: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: add + IL_00b1: conv.u2 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: add + IL_00ce: conv.u2 + IL_00cf: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: add + IL_00eb: conv.u2 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: add + IL_0108: conv.u2 + IL_0109: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.u2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.u2 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: add + IL_015f: conv.u2 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UshortPostIncTest + + .method public hidebysig static void UshortPreIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint16 V_0, + uint16 V_1, + uint16 V_2, + uint16 V_3, + uint16 V_4, + uint16 V_5, + uint16 V_6, + uint16 V_7, + uint16 V_8, + uint16 V_9, + uint16 V_10, + uint16 V_11) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.u2 + IL_0008: dup + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.u2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.u2 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.u2 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005c: ldc.i4.1 + IL_005d: add + IL_005e: conv.u2 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: conv.u2 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008f: ldc.i4.1 + IL_0090: add + IL_0091: conv.u2 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ac: ldc.i4.1 + IL_00ad: add + IL_00ae: conv.u2 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c9: ldc.i4.1 + IL_00ca: add + IL_00cb: conv.u2 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e6: ldc.i4.1 + IL_00e7: add + IL_00e8: conv.u2 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0103: ldc.i4.1 + IL_0104: add + IL_0105: conv.u2 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0120: ldc.i4.1 + IL_0121: add + IL_0122: conv.u2 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013d: ldc.i4.1 + IL_013e: add + IL_013f: conv.u2 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.u2 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UshortPreIncTest + + .method public hidebysig static void UshortPostDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint16 V_0, + uint16 V_1, + uint16 V_2, + uint16 V_3, + uint16 V_4, + uint16 V_5, + uint16 V_6, + uint16 V_7, + uint16 V_8, + uint16 V_9, + uint16 V_10, + uint16 V_11) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.u2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.u2 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.u2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: sub + IL_0060: conv.u2 + IL_0061: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: conv.u2 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: conv.u2 + IL_0095: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: sub + IL_00b1: conv.u2 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: sub + IL_00ce: conv.u2 + IL_00cf: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: sub + IL_00eb: conv.u2 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: sub + IL_0108: conv.u2 + IL_0109: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.u2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.u2 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: sub + IL_015f: conv.u2 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UshortPostDecTest + + .method public hidebysig static void UshortPreDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint16 V_0, + uint16 V_1, + uint16 V_2, + uint16 V_3, + uint16 V_4, + uint16 V_5, + uint16 V_6, + uint16 V_7, + uint16 V_8, + uint16 V_9, + uint16 V_10, + uint16 V_11) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.u2 + IL_0008: dup + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.u2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.u2 + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.u2 + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005c: ldc.i4.1 + IL_005d: sub + IL_005e: conv.u2 + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: conv.u2 + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008f: ldc.i4.1 + IL_0090: sub + IL_0091: conv.u2 + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00ac: ldc.i4.1 + IL_00ad: sub + IL_00ae: conv.u2 + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c9: ldc.i4.1 + IL_00ca: sub + IL_00cb: conv.u2 + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e6: ldc.i4.1 + IL_00e7: sub + IL_00e8: conv.u2 + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0103: ldc.i4.1 + IL_0104: sub + IL_0105: conv.u2 + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0120: ldc.i4.1 + IL_0121: sub + IL_0122: conv.u2 + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013d: ldc.i4.1 + IL_013e: sub + IL_013f: conv.u2 + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.u2 + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UshortPreDecTest + + .method public hidebysig static void IntAddTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: add + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: add + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: add + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: add + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: add + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: add + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: add + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: add + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: add + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: add + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: add + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: add + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntAddTest + + .method public hidebysig static void IntSubtractTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: sub + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: sub + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: sub + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: sub + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: sub + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: sub + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: sub + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: sub + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: sub + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: sub + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: sub + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: sub + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntSubtractTest + + .method public hidebysig static void IntMultiplyTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: mul + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: mul + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: mul + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: mul + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: mul + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: mul + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: mul + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: mul + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: mul + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: mul + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: mul + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: mul + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: mul + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntMultiplyTest + + .method public hidebysig static void IntDivideTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: div + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: div + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: div + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: div + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: div + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: div + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: div + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: div + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: div + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: div + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: div + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: div + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: div + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntDivideTest + + .method public hidebysig static void IntModulusTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: rem + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: rem + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: rem + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: rem + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: rem + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: rem + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: rem + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: rem + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: rem + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: rem + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: rem + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: rem + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: rem + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntModulusTest + + .method public hidebysig static void IntLeftShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: shl + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: shl + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: shl + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: shl + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: shl + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: shl + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: shl + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntLeftShiftTest + + .method public hidebysig static void IntRightShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: shr + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: shr + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: shr + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: shr + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: shr + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: shr + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: shr + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: shr + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: shr + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: shr + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: shr + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: shr + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntRightShiftTest + + .method public hidebysig static void IntBitAndTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: and + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: and + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: and + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: and + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: and + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: and + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: and + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: and + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: and + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: and + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: and + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: and + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: and + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntBitAndTest + + .method public hidebysig static void IntBitOrTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: or + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: or + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: or + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: or + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: or + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: or + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: or + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: or + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: or + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: or + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: or + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: or + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: or + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntBitOrTest + + .method public hidebysig static void IntBitXorTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: xor + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: xor + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: xor + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003c: ldc.i4.5 + IL_003d: xor + IL_003e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: xor + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005d: ldc.i4.5 + IL_005e: xor + IL_005f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006f: ldc.i4.5 + IL_0070: xor + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0081: ldc.i4.5 + IL_0082: xor + IL_0083: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0093: ldc.i4.5 + IL_0094: xor + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: xor + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: xor + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c9: ldc.i4.5 + IL_00ca: xor + IL_00cb: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00db: ldc.i4.5 + IL_00dc: xor + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::IntBitXorTest + + .method public hidebysig static void IntPostIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 351 (0x15f) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1, + int32 V_2, + int32 V_3, + int32 V_4, + int32 V_5, + int32 V_6, + int32 V_7, + int32 V_8, + int32 V_9, + int32 V_10, + int32 V_11) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: dup + IL_002c: stloc.0 + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: dup + IL_0042: stloc.1 + IL_0043: ldc.i4.1 + IL_0044: add + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0058: dup + IL_0059: stloc.2 + IL_005a: ldc.i4.1 + IL_005b: add + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006f: dup + IL_0070: stloc.3 + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0089: dup + IL_008a: stloc.s V_4 + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a5: dup + IL_00a6: stloc.s V_5 + IL_00a8: ldc.i4.1 + IL_00a9: add + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c1: dup + IL_00c2: stloc.s V_6 + IL_00c4: ldc.i4.1 + IL_00c5: add + IL_00c6: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00dd: dup + IL_00de: stloc.s V_7 + IL_00e0: ldc.i4.1 + IL_00e1: add + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f9: dup + IL_00fa: stloc.s V_8 + IL_00fc: ldc.i4.1 + IL_00fd: add + IL_00fe: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0115: dup + IL_0116: stloc.s V_9 + IL_0118: ldc.i4.1 + IL_0119: add + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0131: dup + IL_0132: stloc.s V_10 + IL_0134: ldc.i4.1 + IL_0135: add + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: dup + IL_014e: stloc.s V_11 + IL_0150: ldc.i4.1 + IL_0151: add + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::IntPostIncTest + + .method public hidebysig static void IntPreIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 351 (0x15f) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1, + int32 V_2, + int32 V_3, + int32 V_4, + int32 V_5, + int32 V_6, + int32 V_7, + int32 V_8, + int32 V_9, + int32 V_10, + int32 V_11) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: ldc.i4.1 + IL_0018: add + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: ldc.i4.1 + IL_002c: add + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: ldc.i4.1 + IL_0042: add + IL_0043: dup + IL_0044: stloc.1 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0058: ldc.i4.1 + IL_0059: add + IL_005a: dup + IL_005b: stloc.2 + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006f: ldc.i4.1 + IL_0070: add + IL_0071: dup + IL_0072: stloc.3 + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0089: ldc.i4.1 + IL_008a: add + IL_008b: dup + IL_008c: stloc.s V_4 + IL_008e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a5: ldc.i4.1 + IL_00a6: add + IL_00a7: dup + IL_00a8: stloc.s V_5 + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c1: ldc.i4.1 + IL_00c2: add + IL_00c3: dup + IL_00c4: stloc.s V_6 + IL_00c6: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00dd: ldc.i4.1 + IL_00de: add + IL_00df: dup + IL_00e0: stloc.s V_7 + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f9: ldc.i4.1 + IL_00fa: add + IL_00fb: dup + IL_00fc: stloc.s V_8 + IL_00fe: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0115: ldc.i4.1 + IL_0116: add + IL_0117: dup + IL_0118: stloc.s V_9 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0131: ldc.i4.1 + IL_0132: add + IL_0133: dup + IL_0134: stloc.s V_10 + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: ldc.i4.1 + IL_014e: add + IL_014f: dup + IL_0150: stloc.s V_11 + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::IntPreIncTest + + .method public hidebysig static void IntPostDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 351 (0x15f) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1, + int32 V_2, + int32 V_3, + int32 V_4, + int32 V_5, + int32 V_6, + int32 V_7, + int32 V_8, + int32 V_9, + int32 V_10, + int32 V_11) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: dup + IL_002c: stloc.0 + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: dup + IL_0042: stloc.1 + IL_0043: ldc.i4.1 + IL_0044: sub + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0058: dup + IL_0059: stloc.2 + IL_005a: ldc.i4.1 + IL_005b: sub + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006f: dup + IL_0070: stloc.3 + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0089: dup + IL_008a: stloc.s V_4 + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a5: dup + IL_00a6: stloc.s V_5 + IL_00a8: ldc.i4.1 + IL_00a9: sub + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c1: dup + IL_00c2: stloc.s V_6 + IL_00c4: ldc.i4.1 + IL_00c5: sub + IL_00c6: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00dd: dup + IL_00de: stloc.s V_7 + IL_00e0: ldc.i4.1 + IL_00e1: sub + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f9: dup + IL_00fa: stloc.s V_8 + IL_00fc: ldc.i4.1 + IL_00fd: sub + IL_00fe: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0115: dup + IL_0116: stloc.s V_9 + IL_0118: ldc.i4.1 + IL_0119: sub + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0131: dup + IL_0132: stloc.s V_10 + IL_0134: ldc.i4.1 + IL_0135: sub + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: dup + IL_014e: stloc.s V_11 + IL_0150: ldc.i4.1 + IL_0151: sub + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::IntPostDecTest + + .method public hidebysig static void IntPreDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: mul - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: mul - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Mul + // Code size 351 (0x15f) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1, + int32 V_2, + int32 V_3, + int32 V_4, + int32 V_5, + int32 V_6, + int32 V_7, + int32 V_8, + int32 V_9, + int32 V_10, + int32 V_11) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: ldc.i4.1 + IL_0018: sub + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: ldc.i4.1 + IL_002c: sub + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: ldc.i4.1 + IL_0042: sub + IL_0043: dup + IL_0044: stloc.1 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0058: ldc.i4.1 + IL_0059: sub + IL_005a: dup + IL_005b: stloc.2 + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006f: ldc.i4.1 + IL_0070: sub + IL_0071: dup + IL_0072: stloc.3 + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0089: ldc.i4.1 + IL_008a: sub + IL_008b: dup + IL_008c: stloc.s V_4 + IL_008e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a5: ldc.i4.1 + IL_00a6: sub + IL_00a7: dup + IL_00a8: stloc.s V_5 + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c1: ldc.i4.1 + IL_00c2: sub + IL_00c3: dup + IL_00c4: stloc.s V_6 + IL_00c6: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00dd: ldc.i4.1 + IL_00de: sub + IL_00df: dup + IL_00e0: stloc.s V_7 + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f9: ldc.i4.1 + IL_00fa: sub + IL_00fb: dup + IL_00fc: stloc.s V_8 + IL_00fe: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0115: ldc.i4.1 + IL_0116: sub + IL_0117: dup + IL_0118: stloc.s V_9 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0131: ldc.i4.1 + IL_0132: sub + IL_0133: dup + IL_0134: stloc.s V_10 + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: ldc.i4.1 + IL_014e: sub + IL_014f: dup + IL_0150: stloc.s V_11 + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::IntPreDecTest - .method public hidebysig instance void - Int32_Local_Div(int32 i) cil managed + .method public hidebysig static void UintAddTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: div - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: div - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Div + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: add + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: add + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: add + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: add + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: add + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: add + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: add + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: add + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: add + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: add + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: add + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: add + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintAddTest - .method public hidebysig instance void - Int32_Local_Rem(int32 i) cil managed + .method public hidebysig static void UintSubtractTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: rem - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: rem - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Rem + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: sub + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: sub + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: sub + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: sub + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: sub + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: sub + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: sub + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: sub + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: sub + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: sub + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: sub + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: sub + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintSubtractTest - .method public hidebysig instance void - Int32_Local_BitAnd(int32 i) cil managed + .method public hidebysig static void UintMultiplyTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: and - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: and - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: mul + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: mul + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: mul + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: mul + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: mul + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: mul + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: mul + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: mul + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: mul + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: mul + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: mul + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: mul + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: mul + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintMultiplyTest - .method public hidebysig instance void - Int32_Local_BitOr(int32 i) cil managed + .method public hidebysig static void UintDivideTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: or - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: or - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitOr + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: div.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: div.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: div.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: div.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: div.un + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: div.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: div.un + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: div.un + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: div.un + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: div.un + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: div.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: div.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: div.un + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: div.un + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintDivideTest - .method public hidebysig instance void - Int32_Local_BitXor(int32 i) cil managed + .method public hidebysig static void UintModulusTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: xor - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: xor - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitXor + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: rem.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: rem.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: rem.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: rem.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: rem.un + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: rem.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: rem.un + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: rem.un + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: rem.un + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: rem.un + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: rem.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: rem.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: rem.un + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: rem.un + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintModulusTest - .method public hidebysig instance void - Int32_Local_ShiftLeft(int32 i) cil managed + .method public hidebysig static void UintLeftShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: shl - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: shl - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: shl + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: shl + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: shl + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: shl + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: shl + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: shl + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: shl + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintLeftShiftTest - .method public hidebysig instance void - Int32_Local_ShiftRight(int32 i) cil managed + .method public hidebysig static void UintRightShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: shr - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: shr - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: shr.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: shr.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: shr.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: shr.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: shr.un + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: shr.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: shr.un + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: shr.un + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: shr.un + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: shr.un + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: shr.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: shr.un + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: shr.un + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintRightShiftTest - .method public hidebysig instance void - IntegerWithInline(int32 i) cil managed + .method public hidebysig static void UintBitAndTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: add - IL_0003: dup - IL_0004: starg.s i - IL_0006: call void [mscorlib]System.Console::WriteLine(int32) - IL_000b: ldarg.1 - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: ret - } // end of method CompoundAssignmentTest::IntegerWithInline + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: and + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: and + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: and + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: and + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: and + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: and + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: and + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: and + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: and + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: and + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: and + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: and + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: and + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintBitAndTest - .method public hidebysig instance void - IntegerField(int32 i) cil managed + .method public hidebysig static void UintBitOrTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 67 (0x43) + // Code size 227 (0xe3) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) - IL_0000: ldarg.0 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0007: ldarg.1 - IL_0008: add - IL_0009: dup - IL_000a: stloc.0 - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0010: ldloc.0 - IL_0011: call void [mscorlib]System.Console::WriteLine(int32) - IL_0016: ldarg.0 - IL_0017: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_001c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0021: ldarg.0 - IL_0022: dup - IL_0023: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0028: ldarg.1 - IL_0029: sub - IL_002a: dup - IL_002b: stloc.1 - IL_002c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0031: ldloc.1 - IL_0032: call void [mscorlib]System.Console::WriteLine(int32) - IL_0037: ldarg.0 - IL_0038: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_003d: call void [mscorlib]System.Console::WriteLine(int32) - IL_0042: ret - } // end of method CompoundAssignmentTest::IntegerField + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: or + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: or + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: or + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: or + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: or + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: or + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: or + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: or + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: or + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: or + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: or + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: or + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: or + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintBitOrTest - .method public hidebysig instance void - Array(int32 i) cil managed + .method public hidebysig static void UintBitXorTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 71 (0x47) - .maxstack 4 - .locals init (int32 V_0, - int32 V_1) - IL_0000: ldarg.0 - IL_0001: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0006: ldarg.1 - IL_0007: ldelema [mscorlib]System.Int32 - IL_000c: dup - IL_000d: ldobj [mscorlib]System.Int32 - IL_0012: ldarg.1 - IL_0013: add - IL_0014: dup - IL_0015: stloc.0 - IL_0016: stobj [mscorlib]System.Int32 - IL_001b: ldloc.0 - IL_001c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0021: ldarg.0 - IL_0022: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0027: ldarg.1 - IL_0028: ldc.i4.2 - IL_0029: mul - IL_002a: ldelema [mscorlib]System.Int32 - IL_002f: dup - IL_0030: ldobj [mscorlib]System.Int32 - IL_0035: ldarg.1 - IL_0036: ldc.i4.2 - IL_0037: mul - IL_0038: add - IL_0039: dup - IL_003a: stloc.1 - IL_003b: stobj [mscorlib]System.Int32 - IL_0040: ldloc.1 - IL_0041: call void [mscorlib]System.Console::WriteLine(int32) - IL_0046: ret - } // end of method CompoundAssignmentTest::Array + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: xor + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: xor + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: xor + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003c: ldc.i4.5 + IL_003d: xor + IL_003e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: xor + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005d: ldc.i4.5 + IL_005e: xor + IL_005f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006f: ldc.i4.5 + IL_0070: xor + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0081: ldc.i4.5 + IL_0082: xor + IL_0083: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0093: ldc.i4.5 + IL_0094: xor + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: xor + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: xor + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c9: ldc.i4.5 + IL_00ca: xor + IL_00cb: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00db: ldc.i4.5 + IL_00dc: xor + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UintBitXorTest + + .method public hidebysig static void UintPostIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 351 (0x15f) + .maxstack 3 + .locals init (uint32 V_0, + uint32 V_1, + uint32 V_2, + uint32 V_3, + uint32 V_4, + uint32 V_5, + uint32 V_6, + uint32 V_7, + uint32 V_8, + uint32 V_9, + uint32 V_10, + uint32 V_11) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: dup + IL_002c: stloc.0 + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: dup + IL_0042: stloc.1 + IL_0043: ldc.i4.1 + IL_0044: add + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0058: dup + IL_0059: stloc.2 + IL_005a: ldc.i4.1 + IL_005b: add + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006f: dup + IL_0070: stloc.3 + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0089: dup + IL_008a: stloc.s V_4 + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a5: dup + IL_00a6: stloc.s V_5 + IL_00a8: ldc.i4.1 + IL_00a9: add + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c1: dup + IL_00c2: stloc.s V_6 + IL_00c4: ldc.i4.1 + IL_00c5: add + IL_00c6: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00dd: dup + IL_00de: stloc.s V_7 + IL_00e0: ldc.i4.1 + IL_00e1: add + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f9: dup + IL_00fa: stloc.s V_8 + IL_00fc: ldc.i4.1 + IL_00fd: add + IL_00fe: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0115: dup + IL_0116: stloc.s V_9 + IL_0118: ldc.i4.1 + IL_0119: add + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0131: dup + IL_0132: stloc.s V_10 + IL_0134: ldc.i4.1 + IL_0135: add + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: dup + IL_014e: stloc.s V_11 + IL_0150: ldc.i4.1 + IL_0151: add + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::UintPostIncTest + + .method public hidebysig static void UintPreIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 351 (0x15f) + .maxstack 3 + .locals init (uint32 V_0, + uint32 V_1, + uint32 V_2, + uint32 V_3, + uint32 V_4, + uint32 V_5, + uint32 V_6, + uint32 V_7, + uint32 V_8, + uint32 V_9, + uint32 V_10, + uint32 V_11) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: ldc.i4.1 + IL_0018: add + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: ldc.i4.1 + IL_002c: add + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: ldc.i4.1 + IL_0042: add + IL_0043: dup + IL_0044: stloc.1 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0058: ldc.i4.1 + IL_0059: add + IL_005a: dup + IL_005b: stloc.2 + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006f: ldc.i4.1 + IL_0070: add + IL_0071: dup + IL_0072: stloc.3 + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0089: ldc.i4.1 + IL_008a: add + IL_008b: dup + IL_008c: stloc.s V_4 + IL_008e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a5: ldc.i4.1 + IL_00a6: add + IL_00a7: dup + IL_00a8: stloc.s V_5 + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c1: ldc.i4.1 + IL_00c2: add + IL_00c3: dup + IL_00c4: stloc.s V_6 + IL_00c6: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00dd: ldc.i4.1 + IL_00de: add + IL_00df: dup + IL_00e0: stloc.s V_7 + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f9: ldc.i4.1 + IL_00fa: add + IL_00fb: dup + IL_00fc: stloc.s V_8 + IL_00fe: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0115: ldc.i4.1 + IL_0116: add + IL_0117: dup + IL_0118: stloc.s V_9 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0131: ldc.i4.1 + IL_0132: add + IL_0133: dup + IL_0134: stloc.s V_10 + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: ldc.i4.1 + IL_014e: add + IL_014f: dup + IL_0150: stloc.s V_11 + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::UintPreIncTest - .method public hidebysig instance int32 - ArrayUsageWithMethods() cil managed + .method public hidebysig static void UintPostDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 34 (0x22) + // Code size 351 (0x15f) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() - IL_0006: ldarg.0 - IL_0007: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() - IL_000c: ldelema [mscorlib]System.Int32 - IL_0011: dup - IL_0012: ldobj [mscorlib]System.Int32 + .locals init (uint32 V_0, + uint32 V_1, + uint32 V_2, + uint32 V_3, + uint32 V_4, + uint32 V_5, + uint32 V_6, + uint32 V_7, + uint32 V_8, + uint32 V_9, + uint32 V_10, + uint32 V_11) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() IL_0017: dup - IL_0018: stloc.0 - IL_0019: ldc.i4.1 - IL_001a: add - IL_001b: stobj [mscorlib]System.Int32 - IL_0020: ldloc.0 - IL_0021: ret - } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: dup + IL_002c: stloc.0 + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: dup + IL_0042: stloc.1 + IL_0043: ldc.i4.1 + IL_0044: sub + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0058: dup + IL_0059: stloc.2 + IL_005a: ldc.i4.1 + IL_005b: sub + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006f: dup + IL_0070: stloc.3 + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0089: dup + IL_008a: stloc.s V_4 + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a5: dup + IL_00a6: stloc.s V_5 + IL_00a8: ldc.i4.1 + IL_00a9: sub + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c1: dup + IL_00c2: stloc.s V_6 + IL_00c4: ldc.i4.1 + IL_00c5: sub + IL_00c6: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00dd: dup + IL_00de: stloc.s V_7 + IL_00e0: ldc.i4.1 + IL_00e1: sub + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f9: dup + IL_00fa: stloc.s V_8 + IL_00fc: ldc.i4.1 + IL_00fd: sub + IL_00fe: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0115: dup + IL_0116: stloc.s V_9 + IL_0118: ldc.i4.1 + IL_0119: sub + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0131: dup + IL_0132: stloc.s V_10 + IL_0134: ldc.i4.1 + IL_0135: sub + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: dup + IL_014e: stloc.s V_11 + IL_0150: ldc.i4.1 + IL_0151: sub + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::UintPostDecTest - .method public hidebysig instance void - NestedField() cil managed + .method public hidebysig static void UintPreDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 87 (0x57) + // Code size 351 (0x15f) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) - IL_0000: ldarg.0 - IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0006: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex - IL_000b: brfalse.s IL_0056 - - IL_000d: ldarg.0 - IL_000e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0013: dup - IL_0014: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0019: ldc.i4.2 - IL_001a: mul - IL_001b: dup - IL_001c: stloc.0 - IL_001d: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0022: ldloc.0 - IL_0023: call void [mscorlib]System.Console::WriteLine(int32) - IL_0028: ldarg.0 - IL_0029: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_002e: dup - IL_002f: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0034: ldc.i4.1 - IL_0035: add - IL_0036: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_003b: ldarg.0 - IL_003c: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0041: dup - IL_0042: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0047: dup - IL_0048: stloc.1 - IL_0049: ldc.i4.1 - IL_004a: add - IL_004b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0050: ldloc.1 - IL_0051: call void [mscorlib]System.Console::WriteLine(int32) - IL_0056: ret - } // end of method CompoundAssignmentTest::NestedField + .locals init (uint32 V_0, + uint32 V_1, + uint32 V_2, + uint32 V_3, + uint32 V_4, + uint32 V_5, + uint32 V_6, + uint32 V_7, + uint32 V_8, + uint32 V_9, + uint32 V_10, + uint32 V_11) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: dup + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: ldc.i4.1 + IL_0018: sub + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: ldc.i4.1 + IL_002c: sub + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: ldc.i4.1 + IL_0042: sub + IL_0043: dup + IL_0044: stloc.1 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.1 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: dup + IL_0053: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0058: ldc.i4.1 + IL_0059: sub + IL_005a: dup + IL_005b: stloc.2 + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0061: ldloc.2 + IL_0062: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0067: ldarga.s s + IL_0069: dup + IL_006a: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006f: ldc.i4.1 + IL_0070: sub + IL_0071: dup + IL_0072: stloc.3 + IL_0073: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0078: ldloc.3 + IL_0079: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007e: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0083: dup + IL_0084: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0089: ldc.i4.1 + IL_008a: sub + IL_008b: dup + IL_008c: stloc.s V_4 + IL_008e: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0093: ldloc.s V_4 + IL_0095: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009f: dup + IL_00a0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a5: ldc.i4.1 + IL_00a6: sub + IL_00a7: dup + IL_00a8: stloc.s V_5 + IL_00aa: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00af: ldloc.s V_5 + IL_00b1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c1: ldc.i4.1 + IL_00c2: sub + IL_00c3: dup + IL_00c4: stloc.s V_6 + IL_00c6: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00cb: ldloc.s V_6 + IL_00cd: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d2: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d7: dup + IL_00d8: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00dd: ldc.i4.1 + IL_00de: sub + IL_00df: dup + IL_00e0: stloc.s V_7 + IL_00e2: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e7: ldloc.s V_7 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f3: dup + IL_00f4: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f9: ldc.i4.1 + IL_00fa: sub + IL_00fb: dup + IL_00fc: stloc.s V_8 + IL_00fe: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0103: ldloc.s V_8 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010f: dup + IL_0110: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0115: ldc.i4.1 + IL_0116: sub + IL_0117: dup + IL_0118: stloc.s V_9 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: ldloc.s V_9 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012b: dup + IL_012c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0131: ldc.i4.1 + IL_0132: sub + IL_0133: dup + IL_0134: stloc.s V_10 + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.s V_10 + IL_013d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: ldc.i4.1 + IL_014e: sub + IL_014f: dup + IL_0150: stloc.s V_11 + IL_0152: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0157: ldloc.s V_11 + IL_0159: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015e: ret + } // end of method CompoundAssignmentTest::UintPreDecTest - .method public hidebysig instance void - Enum() cil managed + .method public hidebysig static void LongAddTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 58 (0x3a) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: dup - IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0007: ldc.i4.2 - IL_0008: or - IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_000e: ldarg.0 - IL_000f: dup - IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0015: ldc.i4.s -5 - IL_0017: and - IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_001d: ldarg.0 - IL_001e: dup - IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0024: ldc.i4.2 - IL_0025: add - IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_002b: ldarg.0 - IL_002c: dup - IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0032: ldc.i4.3 - IL_0033: sub - IL_0034: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0039: ret - } // end of method CompoundAssignmentTest::Enum + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: add + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: add + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: add + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: add + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: add + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: add + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: add + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: add + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: add + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: add + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: add + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: add + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: add + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongAddTest - .method public hidebysig instance void - ShortEnumTest() cil managed + .method public hidebysig static void LongSubtractTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 61 (0x3d) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: dup - IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0007: ldc.i4.2 - IL_0008: or - IL_0009: conv.i2 - IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_000f: ldarg.0 - IL_0010: dup - IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0016: ldc.i4.4 - IL_0017: and - IL_0018: conv.i2 - IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_001e: ldarg.0 - IL_001f: dup - IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0025: ldc.i4.2 - IL_0026: add - IL_0027: conv.i2 - IL_0028: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_002d: ldarg.0 - IL_002e: dup - IL_002f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0034: ldc.i4.3 - IL_0035: sub - IL_0036: conv.i2 - IL_0037: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_003c: ret - } // end of method CompoundAssignmentTest::ShortEnumTest + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: sub + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: sub + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: sub + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: sub + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: sub + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: sub + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: sub + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: sub + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: sub + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: sub + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: sub + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: sub + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongSubtractTest - .method public hidebysig instance int32 - PreIncrementInAddition(int32 i, - int32 j) cil managed + .method public hidebysig static void LongMultiplyTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 9 (0x9) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldc.i4.1 - IL_0003: add - IL_0004: dup - IL_0005: starg.s j - IL_0007: add - IL_0008: ret - } // end of method CompoundAssignmentTest::PreIncrementInAddition + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: mul + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: mul + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: mul + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: mul + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: mul + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: mul + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: mul + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: mul + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: mul + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: mul + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: mul + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: mul + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: mul + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: mul + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongMultiplyTest - .method public hidebysig instance int32 - PreIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongDivideTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int32 - IL_000d: ldc.i4.1 - IL_000e: sub - IL_000f: dup - IL_0010: stloc.0 - IL_0011: stobj [mscorlib]System.Int32 - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElement + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: div + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: div + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: div + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: div + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: div + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: div + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: div + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: div + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: div + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: div + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: div + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: div + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: div + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: div + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongDivideTest - .method public hidebysig instance int32 - PostIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongModulusTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int32 - IL_000d: dup - IL_000e: stloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: stobj [mscorlib]System.Int32 - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElement + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: rem + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: rem + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: rem + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: rem + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: rem + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: rem + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: rem + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: rem + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: rem + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: rem + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: rem + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: rem + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: rem + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: rem + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongModulusTest - .method public hidebysig instance void - IncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongLeftShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int32 - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: stobj [mscorlib]System.Int32 - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementArrayElement + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000c: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003c: ldc.i4.5 + IL_003d: shl + IL_003e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005d: ldc.i4.5 + IL_005e: shl + IL_005f: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_006f: ldc.i4.5 + IL_0070: shl + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0081: ldc.i4.5 + IL_0082: shl + IL_0083: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0093: ldc.i4.5 + IL_0094: shl + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00c9: ldc.i4.5 + IL_00ca: shl + IL_00cb: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00db: ldc.i4.5 + IL_00dc: shl + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e2: ret + } // end of method CompoundAssignmentTest::LongLeftShiftTest - .method public hidebysig instance void - DoubleArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongRightShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int32 - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: stobj [mscorlib]System.Int32 - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleArrayElement + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000c: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0011: ldc.i4.5 + IL_0012: shr + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_001f: ldc.i4.5 + IL_0020: shr + IL_0021: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002d: ldc.i4.5 + IL_002e: shr + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003c: ldc.i4.5 + IL_003d: shr + IL_003e: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004b: ldc.i4.5 + IL_004c: shr + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005d: ldc.i4.5 + IL_005e: shr + IL_005f: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_006f: ldc.i4.5 + IL_0070: shr + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0081: ldc.i4.5 + IL_0082: shr + IL_0083: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0093: ldc.i4.5 + IL_0094: shr + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a5: ldc.i4.5 + IL_00a6: shr + IL_00a7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00c9: ldc.i4.5 + IL_00ca: shr + IL_00cb: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00db: ldc.i4.5 + IL_00dc: shr + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e2: ret + } // end of method CompoundAssignmentTest::LongRightShiftTest - .method public hidebysig instance int32 - DoubleArrayElementAndReturn(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongBitAndTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int32 - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: dup - IL_0010: stloc.0 - IL_0011: stobj [mscorlib]System.Int32 - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: and + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: and + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: and + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: and + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: and + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: and + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: and + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: and + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: and + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: and + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: and + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: and + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: and + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: and + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongBitAndTest - .method public hidebysig instance int32 - PreIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongBitOrTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 25 (0x19) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int16 - IL_000d: ldc.i4.1 - IL_000e: sub - IL_000f: conv.i2 - IL_0010: dup - IL_0011: stloc.0 - IL_0012: stobj [mscorlib]System.Int16 - IL_0017: ldloc.0 - IL_0018: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: or + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: or + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: or + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: or + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: or + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: or + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: or + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: or + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: or + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: or + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: or + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: or + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: or + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: or + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongBitOrTest - .method public hidebysig instance int32 - PostIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongBitXorTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 25 (0x19) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int16 - IL_000d: dup - IL_000e: stloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.i2 - IL_0012: stobj [mscorlib]System.Int16 - IL_0017: ldloc.0 - IL_0018: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: xor + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: xor + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: xor + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: xor + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: xor + IL_0043: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: xor + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: xor + IL_0066: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: xor + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: xor + IL_008c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: xor + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: xor + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: xor + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: xor + IL_00d8: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: xor + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::LongBitXorTest - .method public hidebysig instance void - IncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPostIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int16 - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.i2 - IL_0010: stobj [mscorlib]System.Int16 - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementArrayElementShort + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int64 V_0, + int64 V_1, + int64 V_2, + int64 V_3, + int64 V_4, + int64 V_5, + int64 V_6, + int64 V_7, + int64 V_8, + int64 V_9, + int64 V_10, + int64 V_11) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: add + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: add + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: conv.i8 + IL_0060: add + IL_0061: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: conv.i8 + IL_0078: add + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: conv.i8 + IL_0094: add + IL_0095: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: conv.i8 + IL_00ce: add + IL_00cf: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: conv.i8 + IL_00eb: add + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: conv.i8 + IL_0108: add + IL_0109: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: add + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: add + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: conv.i8 + IL_015f: add + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::LongPostIncTest - .method public hidebysig instance void - DoubleArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPreIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int16 - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.i2 - IL_0010: stobj [mscorlib]System.Int16 - IL_0015: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShort + // Code size 365 (0x16d) + .maxstack 3 + .locals init (int64 V_0, + int64 V_1, + int64 V_2, + int64 V_3, + int64 V_4, + int64 V_5, + int64 V_6, + int64 V_7, + int64 V_8, + int64 V_9, + int64 V_10, + int64 V_11) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: add + IL_0008: dup + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: add + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: add + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005c: ldc.i4.1 + IL_005d: conv.i8 + IL_005e: add + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0074: ldc.i4.1 + IL_0075: conv.i8 + IL_0076: add + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008f: ldc.i4.1 + IL_0090: conv.i8 + IL_0091: add + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ac: ldc.i4.1 + IL_00ad: conv.i8 + IL_00ae: add + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c9: ldc.i4.1 + IL_00ca: conv.i8 + IL_00cb: add + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e6: ldc.i4.1 + IL_00e7: conv.i8 + IL_00e8: add + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0103: ldc.i4.1 + IL_0104: conv.i8 + IL_0105: add + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0120: ldc.i4.1 + IL_0121: conv.i8 + IL_0122: add + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013d: ldc.i4.1 + IL_013e: conv.i8 + IL_013f: add + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: add + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::LongPreIncTest - .method public hidebysig instance int16 - DoubleArrayElementShortAndReturn(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPostDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 25 (0x19) + // Code size 365 (0x16d) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldobj [mscorlib]System.Int16 - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.i2 - IL_0010: dup - IL_0011: stloc.0 - IL_0012: stobj [mscorlib]System.Int16 - IL_0017: ldloc.0 - IL_0018: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + .locals init (int64 V_0, + int64 V_1, + int64 V_2, + int64 V_3, + int64 V_4, + int64 V_5, + int64 V_6, + int64 V_7, + int64 V_8, + int64 V_9, + int64 V_10, + int64 V_11) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: sub + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: sub + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: conv.i8 + IL_0060: sub + IL_0061: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: conv.i8 + IL_0078: sub + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: conv.i8 + IL_0094: sub + IL_0095: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: conv.i8 + IL_00ce: sub + IL_00cf: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: conv.i8 + IL_00eb: sub + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: conv.i8 + IL_0108: sub + IL_0109: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: sub + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: sub + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: conv.i8 + IL_015f: sub + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::LongPostDecTest - .method public hidebysig instance int32 - PreIncrementInstanceField() cil managed + .method public hidebysig static void LongPreDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 365 (0x16d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: dup - IL_000f: stloc.0 - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField + .locals init (int64 V_0, + int64 V_1, + int64 V_2, + int64 V_3, + int64 V_4, + int64 V_5, + int64 V_6, + int64 V_7, + int64 V_8, + int64 V_9, + int64 V_10, + int64 V_11) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: dup + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: sub + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005c: ldc.i4.1 + IL_005d: conv.i8 + IL_005e: sub + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0074: ldc.i4.1 + IL_0075: conv.i8 + IL_0076: sub + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008f: ldc.i4.1 + IL_0090: conv.i8 + IL_0091: sub + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00ac: ldc.i4.1 + IL_00ad: conv.i8 + IL_00ae: sub + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c9: ldc.i4.1 + IL_00ca: conv.i8 + IL_00cb: sub + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e6: ldc.i4.1 + IL_00e7: conv.i8 + IL_00e8: sub + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0103: ldc.i4.1 + IL_0104: conv.i8 + IL_0105: sub + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0120: ldc.i4.1 + IL_0121: conv.i8 + IL_0122: sub + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013d: ldc.i4.1 + IL_013e: conv.i8 + IL_013f: sub + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: sub + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::LongPreDecTest - .method public hidebysig instance int32 - PostIncrementInstanceField() cil managed + .method public hidebysig static void UlongAddTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: dup - IL_000d: stloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: add + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: add + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: add + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: add + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: add + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: add + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: add + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: add + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: add + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: add + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: add + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: add + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: add + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongAddTest - .method public hidebysig instance void - IncrementInstanceField() cil managed + .method public hidebysig static void UlongSubtractTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0013: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: sub + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: sub + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: sub + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: sub + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: sub + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: sub + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: sub + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: sub + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: sub + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: sub + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: sub + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: sub + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongSubtractTest - .method public hidebysig instance void - DoubleInstanceField() cil managed + .method public hidebysig static void UlongMultiplyTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleInstanceField + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: mul + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: mul + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: mul + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: mul + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: mul + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: mul + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: mul + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: mul + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: mul + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: mul + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: mul + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: mul + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: mul + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: mul + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongMultiplyTest - .method public hidebysig instance int32 - DoubleInstanceFieldAndReturn() cil managed + .method public hidebysig static void UlongDivideTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: dup - IL_000f: stloc.0 - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: div.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: div.un + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: div.un + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: div.un + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: div.un + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: div.un + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: div.un + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: div.un + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: div.un + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: div.un + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: div.un + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: div.un + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: div.un + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: div.un + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongDivideTest - .method public hidebysig instance int32 - PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongModulusTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: dup - IL_000a: stloc.0 - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0010: ldloc.0 - IL_0011: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: rem.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: rem.un + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: rem.un + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: rem.un + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: rem.un + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: rem.un + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: rem.un + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: rem.un + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: rem.un + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: rem.un + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: rem.un + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: rem.un + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: rem.un + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: rem.un + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongModulusTest - .method public hidebysig instance int32 - PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongLeftShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) + // Code size 227 (0xe3) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: dup - IL_0008: stloc.0 - IL_0009: ldc.i4.1 - IL_000a: add - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0010: ldloc.0 - IL_0011: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000c: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003c: ldc.i4.5 + IL_003d: shl + IL_003e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005d: ldc.i4.5 + IL_005e: shl + IL_005f: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_006f: ldc.i4.5 + IL_0070: shl + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0081: ldc.i4.5 + IL_0082: shl + IL_0083: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0093: ldc.i4.5 + IL_0094: shl + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00c9: ldc.i4.5 + IL_00ca: shl + IL_00cb: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00db: ldc.i4.5 + IL_00dc: shl + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UlongLeftShiftTest + + .method public hidebysig static void UlongRightShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 227 (0xe3) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: shr.un + IL_0007: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000c: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0011: ldc.i4.5 + IL_0012: shr.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_001f: ldc.i4.5 + IL_0020: shr.un + IL_0021: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002d: ldc.i4.5 + IL_002e: shr.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0034: ldarga.s s + IL_0036: dup + IL_0037: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003c: ldc.i4.5 + IL_003d: shr.un + IL_003e: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004b: ldc.i4.5 + IL_004c: shr.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0052: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0057: dup + IL_0058: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005d: ldc.i4.5 + IL_005e: shr.un + IL_005f: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0069: dup + IL_006a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_006f: ldc.i4.5 + IL_0070: shr.un + IL_0071: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0076: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007b: dup + IL_007c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0081: ldc.i4.5 + IL_0082: shr.un + IL_0083: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0088: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008d: dup + IL_008e: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0093: ldc.i4.5 + IL_0094: shr.un + IL_0095: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a5: ldc.i4.5 + IL_00a6: shr.un + IL_00a7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00be: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00c9: ldc.i4.5 + IL_00ca: shr.un + IL_00cb: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d5: dup + IL_00d6: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00db: ldc.i4.5 + IL_00dc: shr.un + IL_00dd: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e2: ret + } // end of method CompoundAssignmentTest::UlongRightShiftTest + + .method public hidebysig static void UlongBitAndTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: and + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: and + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: and + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: and + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: and + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: and + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: and + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: and + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: and + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: and + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: and + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: and + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: and + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: and + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongBitAndTest - .method public hidebysig instance void - IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongBitOrTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField2 + // Code size 241 (0xf1) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: or + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: or + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: or + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: or + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: or + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: or + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: or + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: or + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: or + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: or + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: or + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: or + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: or + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: or + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongBitOrTest - .method public hidebysig instance int32 - PreIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongBitXorTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 241 (0xf1) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.i2 - IL_000f: dup - IL_0010: stloc.0 - IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: xor + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: xor + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: xor + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: xor + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: dup + IL_003b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0040: ldc.i4.5 + IL_0041: conv.i8 + IL_0042: xor + IL_0043: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: xor + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005d: dup + IL_005e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0063: ldc.i4.5 + IL_0064: conv.i8 + IL_0065: xor + IL_0066: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0076: ldc.i4.5 + IL_0077: conv.i8 + IL_0078: xor + IL_0079: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007e: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0083: dup + IL_0084: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0089: ldc.i4.5 + IL_008a: conv.i8 + IL_008b: xor + IL_008c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0091: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0096: dup + IL_0097: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009c: ldc.i4.5 + IL_009d: conv.i8 + IL_009e: xor + IL_009f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: xor + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: xor + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d5: ldc.i4.5 + IL_00d6: conv.i8 + IL_00d7: xor + IL_00d8: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00dd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e2: dup + IL_00e3: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e8: ldc.i4.5 + IL_00e9: conv.i8 + IL_00ea: xor + IL_00eb: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f0: ret + } // end of method CompoundAssignmentTest::UlongBitXorTest - .method public hidebysig instance int32 - PostIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongPostIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 365 (0x16d) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: dup - IL_000d: stloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.i2 - IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + .locals init (uint64 V_0, + uint64 V_1, + uint64 V_2, + uint64 V_3, + uint64 V_4, + uint64 V_5, + uint64 V_6, + uint64 V_7, + uint64 V_8, + uint64 V_9, + uint64 V_10, + uint64 V_11) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: add + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: add + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: conv.i8 + IL_0060: add + IL_0061: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: conv.i8 + IL_0078: add + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: conv.i8 + IL_0094: add + IL_0095: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: conv.i8 + IL_00ce: add + IL_00cf: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: conv.i8 + IL_00eb: add + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: conv.i8 + IL_0108: add + IL_0109: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: add + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: add + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: conv.i8 + IL_015f: add + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UlongPostIncTest - .method public hidebysig instance void - IncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongPreIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.i2 - IL_000f: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + // Code size 365 (0x16d) + .maxstack 3 + .locals init (uint64 V_0, + uint64 V_1, + uint64 V_2, + uint64 V_3, + uint64 V_4, + uint64 V_5, + uint64 V_6, + uint64 V_7, + uint64 V_8, + uint64 V_9, + uint64 V_10, + uint64 V_11) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: add + IL_0008: dup + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: add + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: add + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005c: ldc.i4.1 + IL_005d: conv.i8 + IL_005e: add + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0074: ldc.i4.1 + IL_0075: conv.i8 + IL_0076: add + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008f: ldc.i4.1 + IL_0090: conv.i8 + IL_0091: add + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ac: ldc.i4.1 + IL_00ad: conv.i8 + IL_00ae: add + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c9: ldc.i4.1 + IL_00ca: conv.i8 + IL_00cb: add + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e6: ldc.i4.1 + IL_00e7: conv.i8 + IL_00e8: add + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0103: ldc.i4.1 + IL_0104: conv.i8 + IL_0105: add + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0120: ldc.i4.1 + IL_0121: conv.i8 + IL_0122: add + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013d: ldc.i4.1 + IL_013e: conv.i8 + IL_013f: add + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: add + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UlongPreIncTest - .method public hidebysig instance int32 - PreIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPostDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 365 (0x16d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: dup - IL_000f: stloc.0 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + .locals init (uint64 V_0, + uint64 V_1, + uint64 V_2, + uint64 V_3, + uint64 V_4, + uint64 V_5, + uint64 V_6, + uint64 V_7, + uint64 V_8, + uint64 V_9, + uint64 V_10, + uint64 V_11) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: dup + IL_002e: stloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: sub + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: dup + IL_0045: stloc.1 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: sub + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005c: dup + IL_005d: stloc.2 + IL_005e: ldc.i4.1 + IL_005f: conv.i8 + IL_0060: sub + IL_0061: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0074: dup + IL_0075: stloc.3 + IL_0076: ldc.i4.1 + IL_0077: conv.i8 + IL_0078: sub + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008f: dup + IL_0090: stloc.s V_4 + IL_0092: ldc.i4.1 + IL_0093: conv.i8 + IL_0094: sub + IL_0095: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ac: dup + IL_00ad: stloc.s V_5 + IL_00af: ldc.i4.1 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c9: dup + IL_00ca: stloc.s V_6 + IL_00cc: ldc.i4.1 + IL_00cd: conv.i8 + IL_00ce: sub + IL_00cf: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e6: dup + IL_00e7: stloc.s V_7 + IL_00e9: ldc.i4.1 + IL_00ea: conv.i8 + IL_00eb: sub + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0103: dup + IL_0104: stloc.s V_8 + IL_0106: ldc.i4.1 + IL_0107: conv.i8 + IL_0108: sub + IL_0109: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0120: dup + IL_0121: stloc.s V_9 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: sub + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013d: dup + IL_013e: stloc.s V_10 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: sub + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: dup + IL_015b: stloc.s V_11 + IL_015d: ldc.i4.1 + IL_015e: conv.i8 + IL_015f: sub + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UlongPostDecTest - .method public hidebysig instance int32 - PostIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPreDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 365 (0x16d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: dup - IL_000d: stloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + .locals init (uint64 V_0, + uint64 V_1, + uint64 V_2, + uint64 V_3, + uint64 V_4, + uint64 V_5, + uint64 V_6, + uint64 V_7, + uint64 V_8, + uint64 V_9, + uint64 V_10, + uint64 V_11) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: dup + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: sub + IL_0030: dup + IL_0031: stloc.0 + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: dup + IL_0048: stloc.1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.1 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005c: ldc.i4.1 + IL_005d: conv.i8 + IL_005e: sub + IL_005f: dup + IL_0060: stloc.2 + IL_0061: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0066: ldloc.2 + IL_0067: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0074: ldc.i4.1 + IL_0075: conv.i8 + IL_0076: sub + IL_0077: dup + IL_0078: stloc.3 + IL_0079: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007e: ldloc.3 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0089: dup + IL_008a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008f: ldc.i4.1 + IL_0090: conv.i8 + IL_0091: sub + IL_0092: dup + IL_0093: stloc.s V_4 + IL_0095: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009a: ldloc.s V_4 + IL_009c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a6: dup + IL_00a7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00ac: ldc.i4.1 + IL_00ad: conv.i8 + IL_00ae: sub + IL_00af: dup + IL_00b0: stloc.s V_5 + IL_00b2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b7: ldloc.s V_5 + IL_00b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00be: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c3: dup + IL_00c4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c9: ldc.i4.1 + IL_00ca: conv.i8 + IL_00cb: sub + IL_00cc: dup + IL_00cd: stloc.s V_6 + IL_00cf: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00d4: ldloc.s V_6 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: dup + IL_00e1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e6: ldc.i4.1 + IL_00e7: conv.i8 + IL_00e8: sub + IL_00e9: dup + IL_00ea: stloc.s V_7 + IL_00ec: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f1: ldloc.s V_7 + IL_00f3: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00fd: dup + IL_00fe: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0103: ldc.i4.1 + IL_0104: conv.i8 + IL_0105: sub + IL_0106: dup + IL_0107: stloc.s V_8 + IL_0109: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010e: ldloc.s V_8 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011a: dup + IL_011b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0120: ldc.i4.1 + IL_0121: conv.i8 + IL_0122: sub + IL_0123: dup + IL_0124: stloc.s V_9 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: ldloc.s V_9 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0137: dup + IL_0138: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013d: ldc.i4.1 + IL_013e: conv.i8 + IL_013f: sub + IL_0140: dup + IL_0141: stloc.s V_10 + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.s V_10 + IL_014a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: sub + IL_015d: dup + IL_015e: stloc.s V_11 + IL_0160: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0165: ldloc.s V_11 + IL_0167: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016c: ret + } // end of method CompoundAssignmentTest::UlongPreDecTest - .method public hidebysig instance void - IncrementInstanceProperty() cil managed + .method public hidebysig static void CustomClassAddTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0013: ret - } // end of method CompoundAssignmentTest::IncrementInstanceProperty + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassAddTest - .method public hidebysig instance void - DoubleInstanceProperty() cil managed + .method public hidebysig static void CustomClassSubtractTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleInstanceProperty + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassSubtractTest - .method public hidebysig instance int32 - DoubleInstancePropertyAndReturn() cil managed + .method public hidebysig static void CustomClassMultiplyTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 283 (0x11b) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: dup - IL_000f: stloc.0 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassMultiplyTest - .method public hidebysig instance int32 - PreIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassDivideTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 283 (0x11b) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.u1 - IL_000f: dup - IL_0010: stloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassDivideTest - .method public hidebysig instance int32 - PostIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassModulusTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 283 (0x11b) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: dup - IL_000d: stloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.u1 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassModulusTest - .method public hidebysig instance void - IncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassLeftShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.u1 - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldc.i4.5 + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldc.i4.5 + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldc.i4.5 + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldc.i4.5 + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldc.i4.5 + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldc.i4.5 + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldc.i4.5 + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldc.i4.5 + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldc.i4.5 + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldc.i4.5 + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldc.i4.5 + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldc.i4.5 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldc.i4.5 + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldc.i4.5 + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassLeftShiftTest - .method public hidebysig instance void - DoubleInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassRightShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: conv.u1 - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldc.i4.5 + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldc.i4.5 + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldc.i4.5 + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldc.i4.5 + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldc.i4.5 + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldc.i4.5 + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldc.i4.5 + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldc.i4.5 + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldc.i4.5 + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldc.i4.5 + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldc.i4.5 + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldc.i4.5 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldc.i4.5 + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldc.i4.5 + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassRightShiftTest - .method public hidebysig instance int32 - DoubleInstancePropertyByteAndReturn() cil managed + .method public hidebysig static void CustomClassBitAndTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 283 (0x11b) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: conv.u1 - IL_000f: dup - IL_0010: stloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassBitAndTest + + .method public hidebysig static void CustomClassBitOrTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassBitOrTest - .method public hidebysig instance int32 - PreIncrementStaticField() cil managed + .method public hidebysig static void CustomClassBitXorTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: dup - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticField + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004c: ldnull + IL_004d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0052: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0075: ldnull + IL_0076: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008b: ldnull + IL_008c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a1: ldnull + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b7: ldnull + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f9: ldnull + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_010f: ldnull + IL_0110: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomClassBitXorTest - .method public hidebysig instance int32 - PostIncrementStaticField() cil managed + .method public hidebysig static void CustomClassPostIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + // Code size 393 (0x189) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_2, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_4, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_5, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_6, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_7, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_8, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_9, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_10, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_11) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: dup + IL_001b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: dup + IL_004b: stloc.1 + IL_004c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0064: dup + IL_0065: stloc.2 + IL_0066: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007e: dup + IL_007f: stloc.3 + IL_0080: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_009b: dup + IL_009c: stloc.s V_4 + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00ba: dup + IL_00bb: stloc.s V_5 + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d9: dup + IL_00da: stloc.s V_6 + IL_00dc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e1: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00f8: dup + IL_00f9: stloc.s V_7 + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0117: dup + IL_0118: stloc.s V_8 + IL_011a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0136: dup + IL_0137: stloc.s V_9 + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0155: dup + IL_0156: stloc.s V_10 + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: dup + IL_0175: stloc.s V_11 + IL_0177: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomClassPostIncTest - .method public hidebysig instance void - IncrementStaticField() cil managed + .method public hidebysig static void CustomClassPreIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000c: ret - } // end of method CompoundAssignmentTest::IncrementStaticField + // Code size 393 (0x189) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_2, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_4, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_5, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_6, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_7, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_8, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_9, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_10, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_11) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000a: dup + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0036: dup + IL_0037: stloc.0 + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_004f: dup + IL_0050: stloc.1 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0064: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0069: dup + IL_006a: stloc.2 + IL_006b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0083: dup + IL_0084: stloc.3 + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_009b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a0: dup + IL_00a1: stloc.s V_4 + IL_00a3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00ba: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bf: dup + IL_00c0: stloc.s V_5 + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00de: dup + IL_00df: stloc.s V_6 + IL_00e1: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00fd: dup + IL_00fe: stloc.s V_7 + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: dup + IL_011d: stloc.s V_8 + IL_011f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013b: dup + IL_013c: stloc.s V_9 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015a: dup + IL_015b: stloc.s V_10 + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0179: dup + IL_017a: stloc.s V_11 + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomClassPreIncTest - .method public hidebysig instance void - DoubleStaticField() cil managed + .method public hidebysig static void CustomClassPostDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000c: ret - } // end of method CompoundAssignmentTest::DoubleStaticField + // Code size 393 (0x189) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_2, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_4, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_5, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_6, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_7, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_8, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_9, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_10, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_11) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: dup + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: dup + IL_001b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: dup + IL_004b: stloc.1 + IL_004c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0064: dup + IL_0065: stloc.2 + IL_0066: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007e: dup + IL_007f: stloc.3 + IL_0080: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_009b: dup + IL_009c: stloc.s V_4 + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00ba: dup + IL_00bb: stloc.s V_5 + IL_00bd: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d9: dup + IL_00da: stloc.s V_6 + IL_00dc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e1: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00f8: dup + IL_00f9: stloc.s V_7 + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0117: dup + IL_0118: stloc.s V_8 + IL_011a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0136: dup + IL_0137: stloc.s V_9 + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0155: dup + IL_0156: stloc.s V_10 + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: dup + IL_0175: stloc.s V_11 + IL_0177: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomClassPostDecTest - .method public hidebysig instance int32 - DoubleStaticFieldAndReturn() cil managed + .method public hidebysig static void CustomClassPreDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: dup - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + // Code size 393 (0x189) + .maxstack 3 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_1, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_2, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_3, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_4, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_5, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_6, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_7, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_8, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_9, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_10, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_11) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000a: dup + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0036: dup + IL_0037: stloc.0 + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_004f: dup + IL_0050: stloc.1 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0064: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0069: dup + IL_006a: stloc.2 + IL_006b: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0083: dup + IL_0084: stloc.3 + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_009b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a0: dup + IL_00a1: stloc.s V_4 + IL_00a3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00ba: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bf: dup + IL_00c0: stloc.s V_5 + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00de: dup + IL_00df: stloc.s V_6 + IL_00e1: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00fd: dup + IL_00fe: stloc.s V_7 + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0117: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011c: dup + IL_011d: stloc.s V_8 + IL_011f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0136: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013b: dup + IL_013c: stloc.s V_9 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015a: dup + IL_015b: stloc.s V_10 + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0179: dup + IL_017a: stloc.s V_11 + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomClassPreDecTest - .method public hidebysig instance int32 - PreIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructAddTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: dup - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructAddTest - .method public hidebysig instance int32 - PostIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructSubtractTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructSubtractTest - .method public hidebysig instance void - IncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructMultiplyTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructMultiplyTest - .method public hidebysig instance void - DoubleStaticFieldShort() cil managed + .method public hidebysig static void CustomStructDivideTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: conv.i2 - IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructDivideTest - .method public hidebysig instance int16 - DoubleStaticFieldAndReturnShort() cil managed + .method public hidebysig static void CustomStructModulusTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: conv.i2 - IL_0008: dup - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructModulusTest - .method public hidebysig instance int32 - PreIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructLeftShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: dup - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldc.i4.5 + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0015: ldc.i4.5 + IL_0016: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0027: ldc.i4.5 + IL_0028: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0039: ldc.i4.5 + IL_003a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004c: ldc.i4.5 + IL_004d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0052: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_005f: ldc.i4.5 + IL_0060: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0075: ldc.i4.5 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_008b: ldc.i4.5 + IL_008c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a1: ldc.i4.5 + IL_00a2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00b7: ldc.i4.5 + IL_00b8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00cd: ldc.i4.5 + IL_00ce: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00d3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00e3: ldc.i4.5 + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00f9: ldc.i4.5 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ff: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_010f: ldc.i4.5 + IL_0110: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomStructLeftShiftTest - .method public hidebysig instance int32 - PostIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructRightShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + // Code size 283 (0x11b) + .maxstack 3 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldc.i4.5 + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0015: ldc.i4.5 + IL_0016: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0027: ldc.i4.5 + IL_0028: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0039: ldc.i4.5 + IL_003a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0044: ldarga.s s + IL_0046: dup + IL_0047: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004c: ldc.i4.5 + IL_004d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0052: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_005f: ldc.i4.5 + IL_0060: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006f: dup + IL_0070: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0075: ldc.i4.5 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0080: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0085: dup + IL_0086: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_008b: ldc.i4.5 + IL_008c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0091: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0096: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009b: dup + IL_009c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a1: ldc.i4.5 + IL_00a2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ac: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b1: dup + IL_00b2: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00b7: ldc.i4.5 + IL_00b8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00bd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00cd: ldc.i4.5 + IL_00ce: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00d3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00e3: ldc.i4.5 + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f3: dup + IL_00f4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00f9: ldc.i4.5 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00ff: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0104: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0109: dup + IL_010a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_010f: ldc.i4.5 + IL_0110: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011a: ret + } // end of method CompoundAssignmentTest::CustomStructRightShiftTest - .method public hidebysig instance void - IncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructBitAndTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000c: ret - } // end of method CompoundAssignmentTest::IncrementStaticProperty + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructBitAndTest - .method public hidebysig instance void - DoubleStaticProperty() cil managed + .method public hidebysig static void CustomStructBitOrTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000c: ret - } // end of method CompoundAssignmentTest::DoubleStaticProperty + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructBitOrTest - .method public hidebysig instance int32 - DoubleStaticPropertyAndReturn() cil managed + .method public hidebysig static void CustomStructBitXorTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: dup - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + // Code size 405 (0x195) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_12, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_13) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_1 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.1 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_2 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.2 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_3 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.3 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006c: ldloca.s V_4 + IL_006e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloc.s V_4 + IL_0076: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0080: ldarga.s s + IL_0082: dup + IL_0083: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0088: ldloca.s V_5 + IL_008a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0090: ldloc.s V_5 + IL_0092: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a7: ldloca.s V_6 + IL_00a9: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00af: ldloc.s V_6 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b6: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bb: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c0: dup + IL_00c1: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c6: ldloca.s V_7 + IL_00c8: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ce: ldloc.s V_7 + IL_00d0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00df: dup + IL_00e0: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: ldloca.s V_8 + IL_00e7: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ed: ldloc.s V_8 + IL_00ef: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f4: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00f9: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00fe: dup + IL_00ff: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0104: ldloca.s V_9 + IL_0106: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_010c: ldloc.s V_9 + IL_010e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0113: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0118: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011d: dup + IL_011e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0123: ldloca.s V_10 + IL_0125: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012b: ldloc.s V_10 + IL_012d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0132: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013c: dup + IL_013d: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0142: ldloca.s V_11 + IL_0144: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014a: ldloc.s V_11 + IL_014c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015b: dup + IL_015c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0161: ldloca.s V_12 + IL_0163: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldloc.s V_12 + IL_016b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0170: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0175: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017a: dup + IL_017b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0180: ldloca.s V_13 + IL_0182: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0188: ldloc.s V_13 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: ret + } // end of method CompoundAssignmentTest::CustomStructBitXorTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PreIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPostIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + // Code size 393 (0x189) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: dup + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: dup + IL_001b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: dup + IL_004b: stloc.1 + IL_004c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0064: dup + IL_0065: stloc.2 + IL_0066: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_007e: dup + IL_007f: stloc.3 + IL_0080: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_009b: dup + IL_009c: stloc.s V_4 + IL_009e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ba: dup + IL_00bb: stloc.s V_5 + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: stloc.s V_6 + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00f8: dup + IL_00f9: stloc.s V_7 + IL_00fb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0117: dup + IL_0118: stloc.s V_8 + IL_011a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: dup + IL_0137: stloc.s V_9 + IL_0139: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0155: dup + IL_0156: stloc.s V_10 + IL_0158: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0174: dup + IL_0175: stloc.s V_11 + IL_0177: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomStructPostIncTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PostIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPreIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + // Code size 393 (0x189) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000a: dup + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0036: dup + IL_0037: stloc.0 + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_004f: dup + IL_0050: stloc.1 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0064: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0069: dup + IL_006a: stloc.2 + IL_006b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_007e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0083: dup + IL_0084: stloc.3 + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_009b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a0: dup + IL_00a1: stloc.s V_4 + IL_00a3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ba: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bf: dup + IL_00c0: stloc.s V_5 + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00de: dup + IL_00df: stloc.s V_6 + IL_00e1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00f8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fd: dup + IL_00fe: stloc.s V_7 + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: dup + IL_011d: stloc.s V_8 + IL_011f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: dup + IL_013c: stloc.s V_9 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015a: dup + IL_015b: stloc.s V_10 + IL_015d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0174: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0179: dup + IL_017a: stloc.s V_11 + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomStructPreIncTest + + .method public hidebysig static void CustomStructPostDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 393 (0x189) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: dup + IL_001b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: dup + IL_0032: stloc.0 + IL_0033: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: dup + IL_004b: stloc.1 + IL_004c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0064: dup + IL_0065: stloc.2 + IL_0066: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_007e: dup + IL_007f: stloc.3 + IL_0080: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_009b: dup + IL_009c: stloc.s V_4 + IL_009e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ba: dup + IL_00bb: stloc.s V_5 + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: stloc.s V_6 + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00f8: dup + IL_00f9: stloc.s V_7 + IL_00fb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0117: dup + IL_0118: stloc.s V_8 + IL_011a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: dup + IL_0137: stloc.s V_9 + IL_0139: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0155: dup + IL_0156: stloc.s V_10 + IL_0158: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0174: dup + IL_0175: stloc.s V_11 + IL_0177: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomStructPostDecTest - .method public hidebysig instance void - IncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPreDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) + // Code size 393 (0x189) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_1, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_2, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_3, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_4, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_5, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_6, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_7, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_8, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_9, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_10, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_11) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000a: dup + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0036: dup + IL_0037: stloc.0 + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_004f: dup + IL_0050: stloc.1 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.1 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0064: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0069: dup + IL_006a: stloc.2 + IL_006b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0070: ldloc.2 + IL_0071: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0076: ldarga.s s + IL_0078: dup + IL_0079: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_007e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0083: dup + IL_0084: stloc.3 + IL_0085: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: ldloc.3 + IL_008b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0090: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0095: dup + IL_0096: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_009b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a0: dup + IL_00a1: stloc.s V_4 + IL_00a3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a8: ldloc.s V_4 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b4: dup + IL_00b5: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ba: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bf: dup + IL_00c0: stloc.s V_5 + IL_00c2: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c7: ldloc.s V_5 + IL_00c9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ce: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d3: dup + IL_00d4: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00de: dup + IL_00df: stloc.s V_6 + IL_00e1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: ldloc.s V_6 + IL_00e8: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ed: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f2: dup + IL_00f3: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00f8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fd: dup + IL_00fe: stloc.s V_7 + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0105: ldloc.s V_7 + IL_0107: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0111: dup + IL_0112: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: dup + IL_011d: stloc.s V_8 + IL_011f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0124: ldloc.s V_8 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: dup + IL_013c: stloc.s V_9 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0143: ldloc.s V_9 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014f: dup + IL_0150: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015a: dup + IL_015b: stloc.s V_10 + IL_015d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0162: ldloc.s V_10 + IL_0164: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0174: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0179: dup + IL_017a: stloc.s V_11 + IL_017c: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0181: ldloc.s V_11 + IL_0183: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0188: ret + } // end of method CompoundAssignmentTest::CustomStructPreDecTest + + .method public hidebysig static void AddOneToCustomClass(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& c) cil managed + { + // Code size 30 (0x1e) .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + IL_0000: ldarg.0 + IL_0001: dup + IL_0002: ldind.ref + IL_0003: ldc.i4.1 + IL_0004: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0009: stind.ref + IL_000a: ldarg.0 + IL_000b: ldind.ref + IL_000c: dup + IL_000d: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0012: ldc.i4.1 + IL_0013: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0018: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001d: ret + } // end of method CompoundAssignmentTest::AddOneToCustomClass .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/Item GetItem(object obj) cil managed @@ -1615,25 +19740,20 @@ .method private hidebysig instance void Issue588(uint16 val) cil managed { - // Code size 31 (0x1f) - .maxstack 4 - .locals init (uint16 V_0) + // Code size 27 (0x1b) + .maxstack 8 IL_0000: ldarg.0 IL_0001: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortDict - IL_0006: ldarg.0 - IL_0007: dup - IL_0008: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_000d: dup - IL_000e: stloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.u2 - IL_0012: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_0017: ldloc.0 - IL_0018: ldarg.1 - IL_0019: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, + IL_0006: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000b: dup + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.u2 + IL_000f: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0014: ldarg.1 + IL_0015: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) - IL_001e: ret + IL_001a: ret } // end of method CompoundAssignmentTest::Issue588 .method private hidebysig instance void @@ -1680,6 +19800,58 @@ IL_0011: ret } // end of method CompoundAssignmentTest::.ctor + .property class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CompoundAssignmentTest::CustomClassProp + .property valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + .get valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + } // end of property CompoundAssignmentTest::CustomStructProp + .property uint8 ByteProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + .get uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + } // end of property CompoundAssignmentTest::ByteProp + .property int8 SbyteProp() + { + .get int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + } // end of property CompoundAssignmentTest::SbyteProp + .property int16 ShortProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + .get int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + } // end of property CompoundAssignmentTest::ShortProp + .property uint16 UshortProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + .get uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + } // end of property CompoundAssignmentTest::UshortProp + .property int32 IntProp() + { + .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + } // end of property CompoundAssignmentTest::IntProp + .property uint32 UintProp() + { + .get uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + } // end of property CompoundAssignmentTest::UintProp + .property int64 LongProp() + { + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + .get int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + } // end of property CompoundAssignmentTest::LongProp + .property uint64 UlongProp() + { + .get uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + } // end of property CompoundAssignmentTest::UlongProp .property int32 StaticProperty() { .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() @@ -1697,4 +19869,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\CompoundAssignmentTest.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.roslyn.il index f9df2d1ae..bfe36b460 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.opt.roslyn.il @@ -182,1395 +182,22823 @@ } // end of class Item + .class auto ansi nested public beforefieldinit CustomClass + extends [mscorlib]System.Object + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UlongProp + + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomStructProp + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Subtraction + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Multiply + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Division + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Modulus + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_LeftShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_RightShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_BitwiseAnd + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_BitwiseOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_ExclusiveOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Increment + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomClass::op_Decrement + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method CustomClass::.ctor + + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + } // end of property CustomClass::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + } // end of property CustomClass::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + } // end of property CustomClass::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + } // end of property CustomClass::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + } // end of property CustomClass::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + } // end of property CustomClass::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + } // end of property CustomClass::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + } // end of property CustomClass::UlongProp + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomClass::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomClass::CustomStructProp + } // end of class CustomClass + + .class sequential ansi sealed nested public beforefieldinit CustomStruct + extends [mscorlib]System.ValueType + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_CustomClassProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UlongProp + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Addition + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Subtraction + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Multiply + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Division + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Modulus + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_LeftShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_RightShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_BitwiseAnd + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_BitwiseOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_ExclusiveOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Increment + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CustomStruct::op_Decrement + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct::CustomClassProp + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ByteProp(uint8) + } // end of property CustomStruct::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_SbyteProp(int8) + } // end of property CustomStruct::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ShortProp(int16) + } // end of property CustomStruct::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UshortProp(uint16) + } // end of property CustomStruct::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_IntProp(int32) + } // end of property CustomStruct::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UintProp(uint32) + } // end of property CustomStruct::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_LongProp(int64) + } // end of property CustomStruct::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UlongProp(uint64) + } // end of property CustomStruct::UlongProp + } // end of class CustomStruct + + .class sequential ansi sealed nested public beforefieldinit CustomStruct2 + extends [mscorlib]System.ValueType + { + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomStructProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UlongProp + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct2::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomStruct2::CustomStructProp + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + } // end of property CustomStruct2::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + } // end of property CustomStruct2::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + } // end of property CustomStruct2::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + } // end of property CustomStruct2::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + } // end of property CustomStruct2::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + } // end of property CustomStruct2::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + } // end of property CustomStruct2::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + } // end of property CustomStruct2::UlongProp + } // end of class CustomStruct2 + .field private int32 test1 .field private int32[] array1 .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict - .field private uint16 ushortField .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField .field public static int32 StaticField .field public static int16 StaticShortField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass customClassField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct customStructField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 otherCustomStructField + .field private static uint8 byteField + .field private static int8 sbyteField + .field private static int16 shortField + .field private static uint16 ushortField + .field private static int32 intField + .field private static uint32 uintField + .field private static int64 longField + .field private static uint64 ulongField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field private static uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field private static int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .method private hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomClassProp + + .method private hidebysig specialname static + void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomClassProp + + .method private hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomStructProp + + .method private hidebysig specialname static + void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomStructProp + + .method private hidebysig specialname static + uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ByteProp + + .method private hidebysig specialname static + void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ByteProp + + .method private hidebysig specialname static + int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_SbyteProp + + .method private hidebysig specialname static + void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_SbyteProp + + .method private hidebysig specialname static + int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ShortProp + + .method private hidebysig specialname static + void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ShortProp + + .method private hidebysig specialname static + uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UshortProp + + .method private hidebysig specialname static + void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UshortProp + + .method private hidebysig specialname static + int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_IntProp + + .method private hidebysig specialname static + void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_IntProp + + .method private hidebysig specialname static + uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UintProp + + .method private hidebysig specialname static + void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UintProp + + .method private hidebysig specialname static + int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_LongProp + + .method private hidebysig specialname static + void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_LongProp + + .method private hidebysig specialname static + uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UlongProp + + .method private hidebysig specialname static + void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UlongProp + + .method public hidebysig specialname static + int32 get_StaticProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticProperty + + .method public hidebysig specialname static + void set_StaticProperty(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticProperty + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + get_StaticShortProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticShortProperty + .method public hidebysig specialname static - int32 get_StaticProperty() cil managed + void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticShortProperty + + .method private hidebysig static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& + GetStruct() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetStruct + + .method private hidebysig static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& + GetRefCustomStruct() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefCustomStruct + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& + GetRefCustomClass() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefCustomClass + + .method private hidebysig static uint8& + GetRefByte() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefByte + + .method private hidebysig static int8& + GetRefSbyte() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefSbyte + + .method private hidebysig static int16& + GetRefShort() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefShort + + .method private hidebysig static int32& + GetRefInt() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefInt + + .method private hidebysig static int64& + GetRefLong() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefLong + + .method private hidebysig static uint16& + GetRefUshort() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefUshort + + .method private hidebysig static uint32& + GetRefUint() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefUint + + .method private hidebysig static uint64& + GetRefUlong() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetRefUlong + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + GetClass() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetClass + + .method private hidebysig static void X(!!T result) cil managed + { + // Code size 1 (0x1) + .maxstack 8 + IL_0000: ret + } // end of method CompoundAssignmentTest::X + + .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass + M() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() + IL_0005: ret + } // end of method CompoundAssignmentTest::M + + .method private hidebysig instance int32[0...,0...] + Array() cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: ldnull + IL_0001: ret + } // end of method CompoundAssignmentTest::Array + + .method private hidebysig instance int32* + GetPointer() cil managed + { + // Code size 3 (0x3) + .maxstack 8 + IL_0000: ldc.i4.0 + IL_0001: conv.u + IL_0002: ret + } // end of method CompoundAssignmentTest::GetPointer + + .method public hidebysig instance int32 + GetIndex() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.Random::.ctor() + IL_0005: ldc.i4.0 + IL_0006: ldc.i4.s 100 + IL_0008: callvirt instance int32 [mscorlib]System.Random::Next(int32, + int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::GetIndex + + .method public hidebysig instance int32[] + GetArray() cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method CompoundAssignmentTest::GetArray + + .method public hidebysig instance int32 + GetValue(int32 'value') cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ret + } // end of method CompoundAssignmentTest::GetValue + + .method public hidebysig instance bool + IsUpperCaseA(char a) cil managed + { + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.s 65 + IL_0003: ceq + IL_0005: ret + } // end of method CompoundAssignmentTest::IsUpperCaseA + + .method public hidebysig instance void + Int32_Local_Add(int32 i) cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.1 + IL_0002: add + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ldarg.1 + IL_0011: ldc.i4.1 + IL_0012: add + IL_0013: dup + IL_0014: starg.s i + IL_0016: call void [mscorlib]System.Console::WriteLine(int32) + IL_001b: ldarg.1 + IL_001c: ldc.i4.5 + IL_001d: add + IL_001e: starg.s i + IL_0020: ldarg.1 + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: dup + IL_0024: starg.s i + IL_0026: call void [mscorlib]System.Console::WriteLine(int32) + IL_002b: ret + } // end of method CompoundAssignmentTest::Int32_Local_Add + + .method public hidebysig instance void + Int32_Local_Sub(int32 i) cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.1 + IL_0002: sub + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ldarg.1 + IL_0011: ldc.i4.1 + IL_0012: sub + IL_0013: dup + IL_0014: starg.s i + IL_0016: call void [mscorlib]System.Console::WriteLine(int32) + IL_001b: ldarg.1 + IL_001c: ldc.i4.5 + IL_001d: sub + IL_001e: starg.s i + IL_0020: ldarg.1 + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: dup + IL_0024: starg.s i + IL_0026: call void [mscorlib]System.Console::WriteLine(int32) + IL_002b: ret + } // end of method CompoundAssignmentTest::Int32_Local_Sub + + .method public hidebysig instance void + Int32_Local_Mul(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: mul + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Mul + + .method public hidebysig instance void + Int32_Local_Div(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: div + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Div + + .method public hidebysig instance void + Int32_Local_Rem(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: rem + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_Rem + + .method public hidebysig instance void + Int32_Local_BitAnd(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: and + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + + .method public hidebysig instance void + Int32_Local_BitOr(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: or + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitOr + + .method public hidebysig instance void + Int32_Local_BitXor(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: xor + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitXor + + .method public hidebysig instance void + Int32_Local_ShiftLeft(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: shl + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + + .method public hidebysig instance void + Int32_Local_ShiftRight(int32 i) cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: shr + IL_0003: starg.s i + IL_0005: ldarg.1 + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: dup + IL_0009: starg.s i + IL_000b: call void [mscorlib]System.Console::WriteLine(int32) + IL_0010: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + + .method public hidebysig instance void + IntegerWithInline(int32 i) cil managed + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldc.i4.5 + IL_0002: add + IL_0003: dup + IL_0004: starg.s i + IL_0006: call void [mscorlib]System.Console::WriteLine(int32) + IL_000b: ldarg.1 + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: ret + } // end of method CompoundAssignmentTest::IntegerWithInline + + .method public hidebysig instance void + IntegerField(int32 i) cil managed + { + // Code size 67 (0x43) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldarg.0 + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0007: ldarg.1 + IL_0008: add + IL_0009: dup + IL_000a: stloc.0 + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0010: ldloc.0 + IL_0011: call void [mscorlib]System.Console::WriteLine(int32) + IL_0016: ldarg.0 + IL_0017: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_001c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0021: ldarg.0 + IL_0022: ldarg.0 + IL_0023: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0028: ldarg.1 + IL_0029: sub + IL_002a: dup + IL_002b: stloc.0 + IL_002c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0031: ldloc.0 + IL_0032: call void [mscorlib]System.Console::WriteLine(int32) + IL_0037: ldarg.0 + IL_0038: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_003d: call void [mscorlib]System.Console::WriteLine(int32) + IL_0042: ret + } // end of method CompoundAssignmentTest::IntegerField + + .method public hidebysig instance void + Array(int32 i) cil managed + { + // Code size 55 (0x37) + .maxstack 4 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0006: ldarg.1 + IL_0007: ldelema [mscorlib]System.Int32 + IL_000c: dup + IL_000d: ldind.i4 + IL_000e: ldarg.1 + IL_000f: add + IL_0010: dup + IL_0011: stloc.0 + IL_0012: stind.i4 + IL_0013: ldloc.0 + IL_0014: call void [mscorlib]System.Console::WriteLine(int32) + IL_0019: ldarg.0 + IL_001a: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_001f: ldarg.1 + IL_0020: ldc.i4.2 + IL_0021: mul + IL_0022: ldelema [mscorlib]System.Int32 + IL_0027: dup + IL_0028: ldind.i4 + IL_0029: ldarg.1 + IL_002a: ldc.i4.2 + IL_002b: mul + IL_002c: add + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stind.i4 + IL_0030: ldloc.0 + IL_0031: call void [mscorlib]System.Console::WriteLine(int32) + IL_0036: ret + } // end of method CompoundAssignmentTest::Array + + .method public hidebysig instance int32 + ArrayUsageWithMethods() cil managed + { + // Code size 26 (0x1a) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() + IL_0006: ldarg.0 + IL_0007: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() + IL_000c: ldelema [mscorlib]System.Int32 + IL_0011: dup + IL_0012: ldind.i4 + IL_0013: stloc.0 + IL_0014: ldloc.0 + IL_0015: ldc.i4.1 + IL_0016: add + IL_0017: stind.i4 + IL_0018: ldloc.0 + IL_0019: ret + } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + + .method public hidebysig instance void + NestedField() cil managed + { + // Code size 78 (0x4e) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0006: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex + IL_000b: brfalse.s IL_004d + + IL_000d: ldarg.0 + IL_000e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0013: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0018: dup + IL_0019: ldind.i4 + IL_001a: ldc.i4.2 + IL_001b: mul + IL_001c: dup + IL_001d: stloc.0 + IL_001e: stind.i4 + IL_001f: ldloc.0 + IL_0020: call void [mscorlib]System.Console::WriteLine(int32) + IL_0025: ldarg.0 + IL_0026: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_002b: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0030: dup + IL_0031: ldind.i4 + IL_0032: ldc.i4.1 + IL_0033: add + IL_0034: stind.i4 + IL_0035: ldarg.0 + IL_0036: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_003b: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0040: dup + IL_0041: ldind.i4 + IL_0042: stloc.0 + IL_0043: ldloc.0 + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: stind.i4 + IL_0047: ldloc.0 + IL_0048: call void [mscorlib]System.Console::WriteLine(int32) + IL_004d: ret + } // end of method CompoundAssignmentTest::NestedField + + .method public hidebysig instance void + Enum() cil managed + { + // Code size 58 (0x3a) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.0 + IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0007: ldc.i4.2 + IL_0008: or + IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_000e: ldarg.0 + IL_000f: ldarg.0 + IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0015: ldc.i4.s -5 + IL_0017: and + IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_001d: ldarg.0 + IL_001e: ldarg.0 + IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0024: ldc.i4.2 + IL_0025: add + IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_002b: ldarg.0 + IL_002c: ldarg.0 + IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0032: ldc.i4.3 + IL_0033: sub + IL_0034: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0039: ret + } // end of method CompoundAssignmentTest::Enum + + .method public hidebysig instance void + ShortEnumTest() cil managed + { + // Code size 59 (0x3b) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.0 + IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0007: ldc.i4.2 + IL_0008: or + IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_000e: ldarg.0 + IL_000f: ldarg.0 + IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0015: ldc.i4.4 + IL_0016: and + IL_0017: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_001c: ldarg.0 + IL_001d: ldarg.0 + IL_001e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0023: ldc.i4.2 + IL_0024: add + IL_0025: conv.i2 + IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_002b: ldarg.0 + IL_002c: ldarg.0 + IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0032: ldc.i4.3 + IL_0033: sub + IL_0034: conv.i2 + IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_003a: ret + } // end of method CompoundAssignmentTest::ShortEnumTest + + .method public hidebysig instance int32 + PreIncrementInAddition(int32 i, + int32 j) cil managed + { + // Code size 9 (0x9) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldc.i4.1 + IL_0003: add + IL_0004: dup + IL_0005: starg.s j + IL_0007: add + IL_0008: ret + } // end of method CompoundAssignmentTest::PreIncrementInAddition + + .method public hidebysig instance int32 + PreIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 16 (0x10) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldind.i4 + IL_0009: ldc.i4.1 + IL_000a: sub + IL_000b: stloc.0 + IL_000c: ldloc.0 + IL_000d: stind.i4 + IL_000e: ldloc.0 + IL_000f: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElement + + .method public hidebysig instance int32 + PostIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 16 (0x10) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldind.i4 + IL_0009: stloc.0 + IL_000a: ldloc.0 + IL_000b: ldc.i4.1 + IL_000c: add + IL_000d: stind.i4 + IL_000e: ldloc.0 + IL_000f: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElement + + .method public hidebysig instance void + IncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldind.i4 + IL_0009: ldc.i4.1 + IL_000a: add + IL_000b: stind.i4 + IL_000c: ret + } // end of method CompoundAssignmentTest::IncrementArrayElement + + .method public hidebysig instance void + DoubleArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldind.i4 + IL_0009: ldc.i4.2 + IL_000a: mul + IL_000b: stind.i4 + IL_000c: ret + } // end of method CompoundAssignmentTest::DoubleArrayElement + + .method public hidebysig instance int32 + DoubleArrayElementAndReturn(int32[] 'array', + int32 pos) cil managed + { + // Code size 16 (0x10) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int32 + IL_0007: dup + IL_0008: ldind.i4 + IL_0009: ldc.i4.2 + IL_000a: mul + IL_000b: dup + IL_000c: stloc.0 + IL_000d: stind.i4 + IL_000e: ldloc.0 + IL_000f: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + + .method public hidebysig instance int32 + PreIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 17 (0x11) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldind.i2 + IL_0009: ldc.i4.1 + IL_000a: sub + IL_000b: conv.i2 + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: stind.i2 + IL_000f: ldloc.0 + IL_0010: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + + .method public hidebysig instance int32 + PostIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 17 (0x11) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldind.i2 + IL_0009: stloc.0 + IL_000a: ldloc.0 + IL_000b: ldc.i4.1 + IL_000c: add + IL_000d: conv.i2 + IL_000e: stind.i2 + IL_000f: ldloc.0 + IL_0010: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + + .method public hidebysig instance void + IncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldind.i2 + IL_0009: ldc.i4.1 + IL_000a: add + IL_000b: conv.i2 + IL_000c: stind.i2 + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementArrayElementShort + + .method public hidebysig instance void + DoubleArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldind.i2 + IL_0009: ldc.i4.2 + IL_000a: mul + IL_000b: conv.i2 + IL_000c: stind.i2 + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShort + + .method public hidebysig instance int16 + DoubleArrayElementShortAndReturn(int16[] 'array', + int32 pos) cil managed + { + // Code size 17 (0x11) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.1 + IL_0001: ldarg.2 + IL_0002: ldelema [mscorlib]System.Int16 + IL_0007: dup + IL_0008: ldind.i2 + IL_0009: ldc.i4.2 + IL_000a: mul + IL_000b: conv.i2 + IL_000c: dup + IL_000d: stloc.0 + IL_000e: stind.i2 + IL_000f: ldloc.0 + IL_0010: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: stloc.0 + IL_000f: ldloc.0 + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField + + .method public hidebysig instance int32 + PostIncrementInstanceField() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField + + .method public hidebysig instance void + IncrementInstanceField() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0013: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField + + .method public hidebysig instance void + DoubleInstanceField() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleInstanceField + + .method public hidebysig instance int32 + DoubleInstanceFieldAndReturn() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: dup + IL_000f: stloc.0 + IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 18 (0x12) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stloc.0 + IL_000a: ldloc.0 + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0010: ldloc.0 + IL_0011: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + + .method public hidebysig instance int32 + PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 18 (0x12) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.1 + IL_000a: add + IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0010: ldloc.0 + IL_0011: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + + .method public hidebysig instance void + IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldarg.1 + IL_0001: dup + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField2 + + .method public hidebysig instance int32 + PreIncrementInstanceFieldShort() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.i2 + IL_000f: stloc.0 + IL_0010: ldloc.0 + IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + + .method public hidebysig instance int32 + PostIncrementInstanceFieldShort() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.i2 + IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + + .method public hidebysig instance void + IncrementInstanceFieldShort() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.i2 + IL_000f: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + + .method public hidebysig instance int32 + PreIncrementInstanceProperty() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: stloc.0 + IL_000f: ldloc.0 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + + .method public hidebysig instance int32 + PostIncrementInstanceProperty() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + + .method public hidebysig instance void + IncrementInstanceProperty() cil managed + { + // Code size 22 (0x16) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementInstanceProperty + + .method public hidebysig instance void + DoubleInstanceProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleInstanceProperty + + .method public hidebysig instance int32 + DoubleInstancePropertyAndReturn() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: dup + IL_000f: stloc.0 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0015: ldloc.0 + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + + .method public hidebysig instance int32 + PreIncrementInstancePropertyByte() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.u1 + IL_000f: stloc.0 + IL_0010: ldloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + + .method public hidebysig instance int32 + PostIncrementInstancePropertyByte() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.u1 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + + .method public hidebysig instance void + IncrementInstancePropertyByte() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: ldc.i4.1 + IL_000f: add + IL_0010: conv.u1 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ret + } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + + .method public hidebysig instance void + DoubleInstancePropertyByte() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: conv.u1 + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + + .method public hidebysig instance int32 + DoubleInstancePropertyByteAndReturn() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldarg.0 + IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0006: dup + IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000c: ldc.i4.2 + IL_000d: mul + IL_000e: conv.u1 + IL_000f: dup + IL_0010: stloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0016: ldloc.0 + IL_0017: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticField + + .method public hidebysig instance int32 + PostIncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticField + + .method public hidebysig instance void + IncrementStaticField() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000c: ret + } // end of method CompoundAssignmentTest::IncrementStaticField + + .method public hidebysig instance void + DoubleStaticField() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000c: ret + } // end of method CompoundAssignmentTest::DoubleStaticField + + .method public hidebysig instance int32 + DoubleStaticFieldAndReturn() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + + .method public hidebysig instance int32 + PostIncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + + .method public hidebysig instance void + IncrementStaticFieldShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + + .method public hidebysig instance void + DoubleStaticFieldShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + + .method public hidebysig instance int16 + DoubleStaticFieldAndReturnShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + + .method public hidebysig instance int32 + PreIncrementStaticProperty() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + + .method public hidebysig instance int32 + PostIncrementStaticProperty() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + + .method public hidebysig instance void + IncrementStaticProperty() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000c: ret + } // end of method CompoundAssignmentTest::IncrementStaticProperty + + .method public hidebysig instance void + DoubleStaticProperty() cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000c: ret + } // end of method CompoundAssignmentTest::DoubleStaticProperty + + .method public hidebysig instance int32 + DoubleStaticPropertyAndReturn() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0005: ldc.i4.2 + IL_0006: mul + IL_0007: dup + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PreIncrementStaticPropertyShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PostIncrementStaticPropertyShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + + .method public hidebysig instance void + IncrementStaticPropertyShort() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + + .method public hidebysig static void ByteAddTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: add + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: add + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: add + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: add + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: add + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: add + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: add + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: add + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: add + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: add + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteAddTest + + .method public hidebysig static void ByteSubtractTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: sub + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: sub + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: sub + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: sub + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: sub + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: sub + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: sub + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: sub + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: sub + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: sub + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteSubtractTest + + .method public hidebysig static void ByteMultiplyTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: mul + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: mul + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: mul + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: mul + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: mul + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: mul + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: mul + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: mul + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: mul + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: mul + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteMultiplyTest + + .method public hidebysig static void ByteDivideTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: div + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: div + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: div + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: div + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: div + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: div + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: div + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: div + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: div + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: div + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: div + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: div + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: div + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteDivideTest + + .method public hidebysig static void ByteModulusTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: rem + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: rem + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: rem + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: rem + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: rem + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: rem + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: rem + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: rem + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: rem + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: rem + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: rem + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: rem + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteModulusTest + + .method public hidebysig static void ByteLeftShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: shl + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: shl + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: shl + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: shl + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: shl + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: shl + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: shl + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: shl + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: shl + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: shl + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteLeftShiftTest + + .method public hidebysig static void ByteRightShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: shr + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: shr + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: shr + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: shr + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: shr + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: shr + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: shr + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: shr + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: shr + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: shr + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteRightShiftTest + + .method public hidebysig static void ByteBitAndTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: and + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: and + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: and + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: and + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: and + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: and + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: and + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: and + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: and + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: and + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteBitAndTest + + .method public hidebysig static void ByteBitOrTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: or + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: or + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: or + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: or + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: or + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: or + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: or + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: or + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: or + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: or + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteBitOrTest + + .method public hidebysig static void ByteBitXorTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.u1 + IL_0008: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000d: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.u1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.u1 + IL_0024: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.u1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0038: ldarga.s s + IL_003a: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_003f: dup + IL_0040: ldind.u1 + IL_0041: ldc.i4.5 + IL_0042: xor + IL_0043: conv.u1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_004d: ldc.i4.5 + IL_004e: xor + IL_004f: conv.u1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0060: ldc.i4.5 + IL_0061: xor + IL_0062: conv.u1 + IL_0063: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: conv.u1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0085: dup + IL_0086: ldind.u1 + IL_0087: ldc.i4.5 + IL_0088: xor + IL_0089: conv.u1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0096: ldc.i4.5 + IL_0097: xor + IL_0098: conv.u1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a9: ldc.i4.5 + IL_00aa: xor + IL_00ab: conv.u1 + IL_00ac: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00bc: ldc.i4.5 + IL_00bd: xor + IL_00be: conv.u1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00cf: ldc.i4.5 + IL_00d0: xor + IL_00d1: conv.u1 + IL_00d2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: conv.u1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00f4: dup + IL_00f5: ldind.u1 + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: conv.u1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0105: ldc.i4.5 + IL_0106: xor + IL_0107: conv.u1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_010d: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_0112: dup + IL_0113: ldind.u1 + IL_0114: ldc.i4.5 + IL_0115: xor + IL_0116: conv.u1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::ByteBitXorTest + + .method public hidebysig static void BytePostIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.u1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.u1 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.u1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005b: dup + IL_005c: ldind.u1 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: conv.u1 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: add + IL_0075: conv.u1 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: add + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: add + IL_00ab: conv.u1 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c1: dup + IL_00c2: ldind.u1 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: add + IL_00c7: conv.u1 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: add + IL_00de: conv.u1 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: add + IL_00f9: conv.u1 + IL_00fa: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: add + IL_0114: conv.u1 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: add + IL_012f: conv.u1 + IL_0130: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: add + IL_014a: conv.u1 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0160: dup + IL_0161: ldind.u1 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: add + IL_0166: conv.u1 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: add + IL_017d: conv.u1 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_018e: dup + IL_018f: ldind.u1 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.u1 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::BytePostIncTest + + .method public hidebysig static void BytePreIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.u1 + IL_0008: dup + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.u1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.u1 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.u1 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005b: dup + IL_005c: ldind.u1 + IL_005d: ldc.i4.1 + IL_005e: add + IL_005f: conv.u1 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: conv.u1 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: conv.u1 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00a7: ldc.i4.1 + IL_00a8: add + IL_00a9: conv.u1 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c1: dup + IL_00c2: ldind.u1 + IL_00c3: ldc.i4.1 + IL_00c4: add + IL_00c5: conv.u1 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00da: ldc.i4.1 + IL_00db: add + IL_00dc: conv.u1 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00f5: ldc.i4.1 + IL_00f6: add + IL_00f7: conv.u1 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0110: ldc.i4.1 + IL_0111: add + IL_0112: conv.u1 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_012b: ldc.i4.1 + IL_012c: add + IL_012d: conv.u1 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.u1 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0160: dup + IL_0161: ldind.u1 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.u1 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0179: ldc.i4.1 + IL_017a: add + IL_017b: conv.u1 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_018e: dup + IL_018f: ldind.u1 + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.u1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::BytePreIncTest + + .method public hidebysig static void BytePostDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.u1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.u1 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.u1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005b: dup + IL_005c: ldind.u1 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: conv.u1 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: sub + IL_0075: conv.u1 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: sub + IL_0090: conv.u1 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: sub + IL_00ab: conv.u1 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c1: dup + IL_00c2: ldind.u1 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: sub + IL_00c7: conv.u1 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: sub + IL_00de: conv.u1 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: sub + IL_00f9: conv.u1 + IL_00fa: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: sub + IL_0114: conv.u1 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: sub + IL_012f: conv.u1 + IL_0130: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: sub + IL_014a: conv.u1 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0160: dup + IL_0161: ldind.u1 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: sub + IL_0166: conv.u1 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: sub + IL_017d: conv.u1 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_018e: dup + IL_018f: ldind.u1 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.u1 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::BytePostDecTest + + .method public hidebysig static void BytePreDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.u1 + IL_0008: dup + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.u1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.u1 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.u1 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_005b: dup + IL_005c: ldind.u1 + IL_005d: ldc.i4.1 + IL_005e: sub + IL_005f: conv.u1 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: conv.u1 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: conv.u1 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00a7: ldc.i4.1 + IL_00a8: sub + IL_00a9: conv.u1 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00c1: dup + IL_00c2: ldind.u1 + IL_00c3: ldc.i4.1 + IL_00c4: sub + IL_00c5: conv.u1 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00da: ldc.i4.1 + IL_00db: sub + IL_00dc: conv.u1 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00f5: ldc.i4.1 + IL_00f6: sub + IL_00f7: conv.u1 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0110: ldc.i4.1 + IL_0111: sub + IL_0112: conv.u1 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_012b: ldc.i4.1 + IL_012c: sub + IL_012d: conv.u1 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.u1 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0160: dup + IL_0161: ldind.u1 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.u1 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0179: ldc.i4.1 + IL_017a: sub + IL_017b: conv.u1 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_018e: dup + IL_018f: ldind.u1 + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.u1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::BytePreDecTest + + .method public hidebysig static void SbyteAddTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: add + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: add + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: add + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: add + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: add + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: add + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: add + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: add + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: add + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: add + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteAddTest + + .method public hidebysig static void SbyteSubtractTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: sub + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: sub + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: sub + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: sub + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: sub + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: sub + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: sub + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: sub + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: sub + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: sub + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteSubtractTest + + .method public hidebysig static void SbyteMultiplyTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: mul + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: mul + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: mul + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: mul + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: mul + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: mul + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: mul + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: mul + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: mul + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: mul + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteMultiplyTest + + .method public hidebysig static void SbyteDivideTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: div + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: div + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: div + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: div + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: div + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: div + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: div + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: div + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: div + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: div + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: div + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: div + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: div + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteDivideTest + + .method public hidebysig static void SbyteModulusTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: rem + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: rem + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: rem + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: rem + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: rem + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: rem + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: rem + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: rem + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: rem + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: rem + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: rem + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: rem + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteModulusTest + + .method public hidebysig static void SbyteLeftShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: shl + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: shl + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: shl + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: shl + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: shl + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: shl + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: shl + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: shl + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: shl + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: shl + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteLeftShiftTest + + .method public hidebysig static void SbyteRightShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: shr + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: shr + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: shr + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: shr + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: shr + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: shr + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: shr + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: shr + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: shr + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: shr + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteRightShiftTest + + .method public hidebysig static void SbyteBitAndTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: and + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: and + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: and + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: and + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: and + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: and + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: and + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: and + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: and + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: and + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteBitAndTest + + .method public hidebysig static void SbyteBitOrTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: or + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: or + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: or + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: or + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: or + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: or + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: or + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: or + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: or + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: or + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteBitOrTest + + .method public hidebysig static void SbyteBitXorTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.i1 + IL_0008: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000d: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.i1 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.i1 + IL_0024: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.i1 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0038: ldarga.s s + IL_003a: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_003f: dup + IL_0040: ldind.i1 + IL_0041: ldc.i4.5 + IL_0042: xor + IL_0043: conv.i1 + IL_0044: stind.i1 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_004d: ldc.i4.5 + IL_004e: xor + IL_004f: conv.i1 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0060: ldc.i4.5 + IL_0061: xor + IL_0062: conv.i1 + IL_0063: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: conv.i1 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0085: dup + IL_0086: ldind.i1 + IL_0087: ldc.i4.5 + IL_0088: xor + IL_0089: conv.i1 + IL_008a: stind.i1 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0096: ldc.i4.5 + IL_0097: xor + IL_0098: conv.i1 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a9: ldc.i4.5 + IL_00aa: xor + IL_00ab: conv.i1 + IL_00ac: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00bc: ldc.i4.5 + IL_00bd: xor + IL_00be: conv.i1 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00cf: ldc.i4.5 + IL_00d0: xor + IL_00d1: conv.i1 + IL_00d2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: conv.i1 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00f4: dup + IL_00f5: ldind.i1 + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: conv.i1 + IL_00f9: stind.i1 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0105: ldc.i4.5 + IL_0106: xor + IL_0107: conv.i1 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_010d: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_0112: dup + IL_0113: ldind.i1 + IL_0114: ldc.i4.5 + IL_0115: xor + IL_0116: conv.i1 + IL_0117: stind.i1 + IL_0118: ret + } // end of method CompoundAssignmentTest::SbyteBitXorTest + + .method public hidebysig static void SbytePostIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.i1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.i1 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.i1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005b: dup + IL_005c: ldind.i1 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: conv.i1 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: add + IL_0075: conv.i1 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: add + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: add + IL_00ab: conv.i1 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c1: dup + IL_00c2: ldind.i1 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: add + IL_00c7: conv.i1 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: add + IL_00de: conv.i1 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: add + IL_00f9: conv.i1 + IL_00fa: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: add + IL_0114: conv.i1 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: add + IL_012f: conv.i1 + IL_0130: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: add + IL_014a: conv.i1 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0160: dup + IL_0161: ldind.i1 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: add + IL_0166: conv.i1 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: add + IL_017d: conv.i1 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_018e: dup + IL_018f: ldind.i1 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.i1 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::SbytePostIncTest + + .method public hidebysig static void SbytePreIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i1 + IL_0008: dup + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.i1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.i1 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.i1 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005b: dup + IL_005c: ldind.i1 + IL_005d: ldc.i4.1 + IL_005e: add + IL_005f: conv.i1 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: conv.i1 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: conv.i1 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00a7: ldc.i4.1 + IL_00a8: add + IL_00a9: conv.i1 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c1: dup + IL_00c2: ldind.i1 + IL_00c3: ldc.i4.1 + IL_00c4: add + IL_00c5: conv.i1 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00da: ldc.i4.1 + IL_00db: add + IL_00dc: conv.i1 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00f5: ldc.i4.1 + IL_00f6: add + IL_00f7: conv.i1 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0110: ldc.i4.1 + IL_0111: add + IL_0112: conv.i1 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_012b: ldc.i4.1 + IL_012c: add + IL_012d: conv.i1 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.i1 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0160: dup + IL_0161: ldind.i1 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.i1 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0179: ldc.i4.1 + IL_017a: add + IL_017b: conv.i1 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_018e: dup + IL_018f: ldind.i1 + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.i1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::SbytePreIncTest + + .method public hidebysig static void SbytePostDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.i1 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.i1 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.i1 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005b: dup + IL_005c: ldind.i1 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: conv.i1 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: sub + IL_0075: conv.i1 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: sub + IL_0090: conv.i1 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: sub + IL_00ab: conv.i1 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c1: dup + IL_00c2: ldind.i1 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: sub + IL_00c7: conv.i1 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: sub + IL_00de: conv.i1 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: sub + IL_00f9: conv.i1 + IL_00fa: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: sub + IL_0114: conv.i1 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: sub + IL_012f: conv.i1 + IL_0130: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: sub + IL_014a: conv.i1 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0160: dup + IL_0161: ldind.i1 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: sub + IL_0166: conv.i1 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: sub + IL_017d: conv.i1 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_018e: dup + IL_018f: ldind.i1 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.i1 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::SbytePostDecTest + + .method public hidebysig static void SbytePreDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.i1 + IL_0008: dup + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.i1 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.i1 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.i1 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_005b: dup + IL_005c: ldind.i1 + IL_005d: ldc.i4.1 + IL_005e: sub + IL_005f: conv.i1 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i1 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: conv.i1 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: conv.i1 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00a7: ldc.i4.1 + IL_00a8: sub + IL_00a9: conv.i1 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00c1: dup + IL_00c2: ldind.i1 + IL_00c3: ldc.i4.1 + IL_00c4: sub + IL_00c5: conv.i1 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i1 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00da: ldc.i4.1 + IL_00db: sub + IL_00dc: conv.i1 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00f5: ldc.i4.1 + IL_00f6: sub + IL_00f7: conv.i1 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0110: ldc.i4.1 + IL_0111: sub + IL_0112: conv.i1 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_012b: ldc.i4.1 + IL_012c: sub + IL_012d: conv.i1 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.i1 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0160: dup + IL_0161: ldind.i1 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.i1 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i1 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0179: ldc.i4.1 + IL_017a: sub + IL_017b: conv.i1 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_018e: dup + IL_018f: ldind.i1 + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.i1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i1 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::SbytePreDecTest + + .method public hidebysig static void ShortAddTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: add + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: add + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: add + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: add + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: add + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: add + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: add + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: add + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: add + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: add + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortAddTest + + .method public hidebysig static void ShortSubtractTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: sub + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: sub + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: sub + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: sub + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: sub + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: sub + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: sub + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: sub + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: sub + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: sub + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortSubtractTest + + .method public hidebysig static void ShortMultiplyTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: mul + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: mul + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: mul + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: mul + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: mul + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: mul + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: mul + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: mul + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: mul + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: mul + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortMultiplyTest + + .method public hidebysig static void ShortDivideTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: div + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: div + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: div + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: div + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: div + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: div + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: div + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: div + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: div + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: div + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: div + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: div + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: div + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortDivideTest + + .method public hidebysig static void ShortModulusTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: rem + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: rem + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: rem + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: rem + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: rem + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: rem + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: rem + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: rem + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: rem + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: rem + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: rem + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: rem + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortModulusTest + + .method public hidebysig static void ShortLeftShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: shl + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: shl + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: shl + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: shl + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: shl + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: shl + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: shl + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: shl + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: shl + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: shl + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortLeftShiftTest + + .method public hidebysig static void ShortRightShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: shr + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: shr + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: shr + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: shr + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: shr + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: shr + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: shr + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: shr + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: shr + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: shr + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortRightShiftTest + + .method public hidebysig static void ShortBitAndTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: and + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: and + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: and + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: and + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: and + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: and + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: and + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: and + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: and + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: and + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortBitAndTest + + .method public hidebysig static void ShortBitOrTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: or + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: or + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: or + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: or + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: or + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: or + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: or + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: or + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: or + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: or + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortBitOrTest + + .method public hidebysig static void ShortBitXorTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.i2 + IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000d: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.i2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.i2 + IL_0024: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.i2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0038: ldarga.s s + IL_003a: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_003f: dup + IL_0040: ldind.i2 + IL_0041: ldc.i4.5 + IL_0042: xor + IL_0043: conv.i2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_004d: ldc.i4.5 + IL_004e: xor + IL_004f: conv.i2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0060: ldc.i4.5 + IL_0061: xor + IL_0062: conv.i2 + IL_0063: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: conv.i2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0085: dup + IL_0086: ldind.i2 + IL_0087: ldc.i4.5 + IL_0088: xor + IL_0089: conv.i2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0096: ldc.i4.5 + IL_0097: xor + IL_0098: conv.i2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a9: ldc.i4.5 + IL_00aa: xor + IL_00ab: conv.i2 + IL_00ac: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00bc: ldc.i4.5 + IL_00bd: xor + IL_00be: conv.i2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00cf: ldc.i4.5 + IL_00d0: xor + IL_00d1: conv.i2 + IL_00d2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: conv.i2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00f4: dup + IL_00f5: ldind.i2 + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: conv.i2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0105: ldc.i4.5 + IL_0106: xor + IL_0107: conv.i2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_010d: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_0112: dup + IL_0113: ldind.i2 + IL_0114: ldc.i4.5 + IL_0115: xor + IL_0116: conv.i2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::ShortBitXorTest + + .method public hidebysig static void ShortPostIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.i2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.i2 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.i2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005b: dup + IL_005c: ldind.i2 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: conv.i2 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: add + IL_0075: conv.i2 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: add + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: add + IL_00ab: conv.i2 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c1: dup + IL_00c2: ldind.i2 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: add + IL_00c7: conv.i2 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: add + IL_00de: conv.i2 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: add + IL_00f9: conv.i2 + IL_00fa: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: add + IL_0114: conv.i2 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: add + IL_012f: conv.i2 + IL_0130: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: add + IL_014a: conv.i2 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0160: dup + IL_0161: ldind.i2 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: add + IL_0166: conv.i2 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: add + IL_017d: conv.i2 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_018e: dup + IL_018f: ldind.i2 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.i2 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::ShortPostIncTest + + .method public hidebysig static void ShortPreIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.i2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.i2 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.i2 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005b: dup + IL_005c: ldind.i2 + IL_005d: ldc.i4.1 + IL_005e: add + IL_005f: conv.i2 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: conv.i2 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: conv.i2 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00a7: ldc.i4.1 + IL_00a8: add + IL_00a9: conv.i2 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c1: dup + IL_00c2: ldind.i2 + IL_00c3: ldc.i4.1 + IL_00c4: add + IL_00c5: conv.i2 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00da: ldc.i4.1 + IL_00db: add + IL_00dc: conv.i2 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00f5: ldc.i4.1 + IL_00f6: add + IL_00f7: conv.i2 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0110: ldc.i4.1 + IL_0111: add + IL_0112: conv.i2 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_012b: ldc.i4.1 + IL_012c: add + IL_012d: conv.i2 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.i2 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0160: dup + IL_0161: ldind.i2 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.i2 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0179: ldc.i4.1 + IL_017a: add + IL_017b: conv.i2 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_018e: dup + IL_018f: ldind.i2 + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.i2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::ShortPreIncTest + + .method public hidebysig static void ShortPostDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.i2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.i2 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.i2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005b: dup + IL_005c: ldind.i2 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: conv.i2 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: sub + IL_0075: conv.i2 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: sub + IL_0090: conv.i2 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: sub + IL_00ab: conv.i2 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c1: dup + IL_00c2: ldind.i2 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: sub + IL_00c7: conv.i2 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: sub + IL_00de: conv.i2 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: sub + IL_00f9: conv.i2 + IL_00fa: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: sub + IL_0114: conv.i2 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: sub + IL_012f: conv.i2 + IL_0130: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: sub + IL_014a: conv.i2 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0160: dup + IL_0161: ldind.i2 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: sub + IL_0166: conv.i2 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: sub + IL_017d: conv.i2 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_018e: dup + IL_018f: ldind.i2 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.i2 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::ShortPostDecTest + + .method public hidebysig static void ShortPreDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.i2 + IL_0008: dup + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.i2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.i2 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.i2 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_005b: dup + IL_005c: ldind.i2 + IL_005d: ldc.i4.1 + IL_005e: sub + IL_005f: conv.i2 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: conv.i2 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: conv.i2 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00a7: ldc.i4.1 + IL_00a8: sub + IL_00a9: conv.i2 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00c1: dup + IL_00c2: ldind.i2 + IL_00c3: ldc.i4.1 + IL_00c4: sub + IL_00c5: conv.i2 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00da: ldc.i4.1 + IL_00db: sub + IL_00dc: conv.i2 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00f5: ldc.i4.1 + IL_00f6: sub + IL_00f7: conv.i2 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0110: ldc.i4.1 + IL_0111: sub + IL_0112: conv.i2 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_012b: ldc.i4.1 + IL_012c: sub + IL_012d: conv.i2 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.i2 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0160: dup + IL_0161: ldind.i2 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.i2 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0179: ldc.i4.1 + IL_017a: sub + IL_017b: conv.i2 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_018e: dup + IL_018f: ldind.i2 + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.i2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::ShortPreDecTest + + .method public hidebysig static void UshortAddTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: add + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: add + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: add + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: add + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: add + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: add + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: add + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: add + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: add + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: add + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: add + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: add + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: add + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortAddTest + + .method public hidebysig static void UshortSubtractTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: sub + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: sub + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: sub + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: sub + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: sub + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: sub + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: sub + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: sub + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: sub + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: sub + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: sub + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: sub + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: sub + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortSubtractTest + + .method public hidebysig static void UshortMultiplyTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: mul + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: mul + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: mul + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: mul + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: mul + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: mul + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: mul + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: mul + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: mul + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: mul + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: mul + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: mul + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: mul + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortMultiplyTest + + .method public hidebysig static void UshortDivideTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: div + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: div + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: div + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: div + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: div + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: div + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: div + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: div + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: div + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: div + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: div + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: div + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: div + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: div + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortDivideTest + + .method public hidebysig static void UshortModulusTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: rem + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: rem + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: rem + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: rem + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: rem + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: rem + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: rem + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: rem + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: rem + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: rem + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: rem + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: rem + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: rem + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: rem + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortModulusTest + + .method public hidebysig static void UshortLeftShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: shl + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: shl + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: shl + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: shl + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: shl + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: shl + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: shl + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: shl + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: shl + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: shl + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: shl + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: shl + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: shl + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortLeftShiftTest + + .method public hidebysig static void UshortRightShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: shr + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: shr + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: shr + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: shr + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: shr + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: shr + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: shr + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: shr + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: shr + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: shr + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: shr + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: shr + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: shr + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortRightShiftTest + + .method public hidebysig static void UshortBitAndTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: and + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: and + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: and + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: and + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: and + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: and + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: and + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: and + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: and + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: and + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: and + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: and + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: and + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortBitAndTest + + .method public hidebysig static void UshortBitOrTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: or + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: or + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: or + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: or + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: or + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: or + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: or + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: or + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: or + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: or + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: or + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: or + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: or + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortBitOrTest + + .method public hidebysig static void UshortBitXorTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticProperty + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: conv.u2 + IL_0008: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000d: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: conv.u2 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: conv.u2 + IL_0024: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0030: ldc.i4.5 + IL_0031: xor + IL_0032: conv.u2 + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0038: ldarga.s s + IL_003a: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_003f: dup + IL_0040: ldind.u2 + IL_0041: ldc.i4.5 + IL_0042: xor + IL_0043: conv.u2 + IL_0044: stind.i2 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_004d: ldc.i4.5 + IL_004e: xor + IL_004f: conv.u2 + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0060: ldc.i4.5 + IL_0061: xor + IL_0062: conv.u2 + IL_0063: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0073: ldc.i4.5 + IL_0074: xor + IL_0075: conv.u2 + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0085: dup + IL_0086: ldind.u2 + IL_0087: ldc.i4.5 + IL_0088: xor + IL_0089: conv.u2 + IL_008a: stind.i2 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0096: ldc.i4.5 + IL_0097: xor + IL_0098: conv.u2 + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a9: ldc.i4.5 + IL_00aa: xor + IL_00ab: conv.u2 + IL_00ac: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00bc: ldc.i4.5 + IL_00bd: xor + IL_00be: conv.u2 + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00cf: ldc.i4.5 + IL_00d0: xor + IL_00d1: conv.u2 + IL_00d2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e2: ldc.i4.5 + IL_00e3: xor + IL_00e4: conv.u2 + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00f4: dup + IL_00f5: ldind.u2 + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: conv.u2 + IL_00f9: stind.i2 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0105: ldc.i4.5 + IL_0106: xor + IL_0107: conv.u2 + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_010d: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_0112: dup + IL_0113: ldind.u2 + IL_0114: ldc.i4.5 + IL_0115: xor + IL_0116: conv.u2 + IL_0117: stind.i2 + IL_0118: ret + } // end of method CompoundAssignmentTest::UshortBitXorTest - .method public hidebysig specialname static - void set_StaticProperty(int32 'value') cil managed + .method public hidebysig static void UshortPostIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticProperty + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: conv.u2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: conv.u2 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: conv.u2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005b: dup + IL_005c: ldind.u2 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: add + IL_0061: conv.u2 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: add + IL_0075: conv.u2 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: add + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: add + IL_00ab: conv.u2 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c1: dup + IL_00c2: ldind.u2 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: add + IL_00c7: conv.u2 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: add + IL_00de: conv.u2 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: add + IL_00f9: conv.u2 + IL_00fa: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: add + IL_0114: conv.u2 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: add + IL_012f: conv.u2 + IL_0130: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: add + IL_014a: conv.u2 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0160: dup + IL_0161: ldind.u2 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: add + IL_0166: conv.u2 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: add + IL_017d: conv.u2 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_018e: dup + IL_018f: ldind.u2 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.u2 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UshortPostIncTest - .method public hidebysig specialname static - valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - get_StaticShortProperty() cil managed + .method public hidebysig static void UshortPreIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticShortProperty + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: conv.u2 + IL_0008: dup + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: conv.u2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: conv.u2 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: ldc.i4.1 + IL_0045: add + IL_0046: conv.u2 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005b: dup + IL_005c: ldind.u2 + IL_005d: ldc.i4.1 + IL_005e: add + IL_005f: conv.u2 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0071: ldc.i4.1 + IL_0072: add + IL_0073: conv.u2 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008c: ldc.i4.1 + IL_008d: add + IL_008e: conv.u2 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00a7: ldc.i4.1 + IL_00a8: add + IL_00a9: conv.u2 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c1: dup + IL_00c2: ldind.u2 + IL_00c3: ldc.i4.1 + IL_00c4: add + IL_00c5: conv.u2 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00da: ldc.i4.1 + IL_00db: add + IL_00dc: conv.u2 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00f5: ldc.i4.1 + IL_00f6: add + IL_00f7: conv.u2 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0110: ldc.i4.1 + IL_0111: add + IL_0112: conv.u2 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_012b: ldc.i4.1 + IL_012c: add + IL_012d: conv.u2 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0146: ldc.i4.1 + IL_0147: add + IL_0148: conv.u2 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0160: dup + IL_0161: ldind.u2 + IL_0162: ldc.i4.1 + IL_0163: add + IL_0164: conv.u2 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0179: ldc.i4.1 + IL_017a: add + IL_017b: conv.u2 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_018e: dup + IL_018f: ldind.u2 + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.u2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UshortPreIncTest - .method public hidebysig specialname static - void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + .method public hidebysig static void UshortPostDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticShortProperty + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: conv.u2 + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: conv.u2 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: conv.u2 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005b: dup + IL_005c: ldind.u2 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: sub + IL_0061: conv.u2 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: sub + IL_0075: conv.u2 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: sub + IL_0090: conv.u2 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: sub + IL_00ab: conv.u2 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c1: dup + IL_00c2: ldind.u2 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: sub + IL_00c7: conv.u2 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: sub + IL_00de: conv.u2 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: sub + IL_00f9: conv.u2 + IL_00fa: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: sub + IL_0114: conv.u2 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: sub + IL_012f: conv.u2 + IL_0130: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: sub + IL_014a: conv.u2 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0160: dup + IL_0161: ldind.u2 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: sub + IL_0166: conv.u2 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: sub + IL_017d: conv.u2 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_018e: dup + IL_018f: ldind.u2 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.u2 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UshortPostDecTest - .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass - M() cil managed + .method public hidebysig static void UshortPreDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() - IL_0005: ret - } // end of method CompoundAssignmentTest::M + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: conv.u2 + IL_0008: dup + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: conv.u2 + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: conv.u2 + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0044: ldc.i4.1 + IL_0045: sub + IL_0046: conv.u2 + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_005b: dup + IL_005c: ldind.u2 + IL_005d: ldc.i4.1 + IL_005e: sub + IL_005f: conv.u2 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i2 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0071: ldc.i4.1 + IL_0072: sub + IL_0073: conv.u2 + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_008c: ldc.i4.1 + IL_008d: sub + IL_008e: conv.u2 + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00a7: ldc.i4.1 + IL_00a8: sub + IL_00a9: conv.u2 + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00c1: dup + IL_00c2: ldind.u2 + IL_00c3: ldc.i4.1 + IL_00c4: sub + IL_00c5: conv.u2 + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i2 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00da: ldc.i4.1 + IL_00db: sub + IL_00dc: conv.u2 + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00f5: ldc.i4.1 + IL_00f6: sub + IL_00f7: conv.u2 + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0110: ldc.i4.1 + IL_0111: sub + IL_0112: conv.u2 + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_012b: ldc.i4.1 + IL_012c: sub + IL_012d: conv.u2 + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0146: ldc.i4.1 + IL_0147: sub + IL_0148: conv.u2 + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0160: dup + IL_0161: ldind.u2 + IL_0162: ldc.i4.1 + IL_0163: sub + IL_0164: conv.u2 + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i2 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0179: ldc.i4.1 + IL_017a: sub + IL_017b: conv.u2 + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_018e: dup + IL_018f: ldind.u2 + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.u2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i2 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UshortPreDecTest - .method private hidebysig instance int32[0...,0...] - Array() cil managed + .method public hidebysig static void IntAddTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 2 (0x2) - .maxstack 8 - IL_0000: ldnull - IL_0001: ret - } // end of method CompoundAssignmentTest::Array + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: add + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: add + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: add + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: add + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: add + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: add + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: add + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: add + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: add + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: add + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: add + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: add + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntAddTest - .method private hidebysig instance int32* - GetPointer() cil managed + .method public hidebysig static void IntSubtractTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 3 (0x3) - .maxstack 8 - IL_0000: ldc.i4.0 - IL_0001: conv.u - IL_0002: ret - } // end of method CompoundAssignmentTest::GetPointer + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: sub + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: sub + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: sub + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: sub + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: sub + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: sub + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: sub + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: sub + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: sub + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: sub + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: sub + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: sub + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntSubtractTest - .method public hidebysig instance int32 - GetIndex() cil managed + .method public hidebysig static void IntMultiplyTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: newobj instance void [mscorlib]System.Random::.ctor() - IL_0005: ldc.i4.0 - IL_0006: ldc.i4.s 100 - IL_0008: callvirt instance int32 [mscorlib]System.Random::Next(int32, - int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::GetIndex + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: mul + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: mul + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: mul + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: mul + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: mul + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: mul + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: mul + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: mul + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: mul + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: mul + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: mul + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: mul + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: mul + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntMultiplyTest - .method public hidebysig instance int32[] - GetArray() cil managed + .method public hidebysig static void IntDivideTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0005: throw - } // end of method CompoundAssignmentTest::GetArray + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: div + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: div + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: div + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: div + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: div + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: div + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: div + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: div + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: div + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: div + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: div + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: div + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: div + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: div + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: div + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: div + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: div + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntDivideTest - .method public hidebysig instance int32 - GetValue(int32 'value') cil managed + .method public hidebysig static void IntModulusTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 2 (0x2) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ret - } // end of method CompoundAssignmentTest::GetValue + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: rem + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: rem + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: rem + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: rem + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: rem + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: rem + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: rem + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: rem + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: rem + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: rem + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: rem + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: rem + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: rem + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: rem + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: rem + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: rem + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: rem + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntModulusTest - .method public hidebysig instance bool - IsUpperCaseA(char a) cil managed + .method public hidebysig static void IntLeftShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.s 65 - IL_0003: ceq - IL_0005: ret - } // end of method CompoundAssignmentTest::IsUpperCaseA + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: shl + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: shl + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: shl + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: shl + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: shl + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: shl + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: shl + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: shl + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: shl + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: shl + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntLeftShiftTest - .method public hidebysig instance void - Int32_Local_Add(int32 i) cil managed + .method public hidebysig static void IntRightShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 44 (0x2c) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.1 - IL_0002: add - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ldarg.1 - IL_0011: ldc.i4.1 - IL_0012: add - IL_0013: dup - IL_0014: starg.s i - IL_0016: call void [mscorlib]System.Console::WriteLine(int32) - IL_001b: ldarg.1 - IL_001c: ldc.i4.5 - IL_001d: add - IL_001e: starg.s i - IL_0020: ldarg.1 - IL_0021: ldc.i4.5 - IL_0022: add - IL_0023: dup - IL_0024: starg.s i - IL_0026: call void [mscorlib]System.Console::WriteLine(int32) - IL_002b: ret - } // end of method CompoundAssignmentTest::Int32_Local_Add + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: shr + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: shr + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: shr + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: shr + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: shr + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: shr + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: shr + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: shr + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: shr + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: shr + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: shr + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: shr + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: shr + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntRightShiftTest - .method public hidebysig instance void - Int32_Local_Sub(int32 i) cil managed + .method public hidebysig static void IntBitAndTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 44 (0x2c) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.1 - IL_0002: sub - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: sub - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ldarg.1 - IL_0011: ldc.i4.1 - IL_0012: sub - IL_0013: dup - IL_0014: starg.s i - IL_0016: call void [mscorlib]System.Console::WriteLine(int32) - IL_001b: ldarg.1 - IL_001c: ldc.i4.5 - IL_001d: sub - IL_001e: starg.s i - IL_0020: ldarg.1 - IL_0021: ldc.i4.5 - IL_0022: sub - IL_0023: dup - IL_0024: starg.s i - IL_0026: call void [mscorlib]System.Console::WriteLine(int32) - IL_002b: ret - } // end of method CompoundAssignmentTest::Int32_Local_Sub + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: and + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: and + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: and + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: and + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: and + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: and + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: and + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: and + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: and + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: and + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: and + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: and + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: and + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntBitAndTest - .method public hidebysig instance void - Int32_Local_Mul(int32 i) cil managed + .method public hidebysig static void IntBitOrTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: mul - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: mul - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Mul + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: or + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: or + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: or + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: or + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: or + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: or + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: or + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: or + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: or + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: or + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: or + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: or + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: or + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntBitOrTest + + .method public hidebysig static void IntBitXorTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000c: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0011: ldc.i4.5 + IL_0012: xor + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_001f: ldc.i4.5 + IL_0020: xor + IL_0021: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002d: ldc.i4.5 + IL_002e: xor + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0034: ldarga.s s + IL_0036: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003b: dup + IL_003c: ldind.i4 + IL_003d: ldc.i4.5 + IL_003e: xor + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0048: ldc.i4.5 + IL_0049: xor + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005a: ldc.i4.5 + IL_005b: xor + IL_005c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_006c: ldc.i4.5 + IL_006d: xor + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_007d: dup + IL_007e: ldind.i4 + IL_007f: ldc.i4.5 + IL_0080: xor + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_008d: ldc.i4.5 + IL_008e: xor + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_009f: ldc.i4.5 + IL_00a0: xor + IL_00a1: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b1: ldc.i4.5 + IL_00b2: xor + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00c3: ldc.i4.5 + IL_00c4: xor + IL_00c5: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00e6: dup + IL_00e7: ldind.i4 + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00fd: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0102: dup + IL_0103: ldind.i4 + IL_0104: ldc.i4.5 + IL_0105: xor + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::IntBitXorTest + + .method public hidebysig static void IntPostIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 396 (0x18c) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: stloc.0 + IL_002c: ldloc.0 + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: stloc.0 + IL_0042: ldloc.0 + IL_0043: ldc.i4.1 + IL_0044: add + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0057: dup + IL_0058: ldind.i4 + IL_0059: stloc.0 + IL_005a: ldloc.0 + IL_005b: ldc.i4.1 + IL_005c: add + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: ldc.i4.1 + IL_006f: add + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0086: stloc.0 + IL_0087: ldloc.0 + IL_0088: ldc.i4.1 + IL_0089: add + IL_008a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: ldc.i4.1 + IL_00a3: add + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00b9: dup + IL_00ba: ldind.i4 + IL_00bb: stloc.0 + IL_00bc: ldloc.0 + IL_00bd: ldc.i4.1 + IL_00be: add + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00d1: stloc.0 + IL_00d2: ldloc.0 + IL_00d3: ldc.i4.1 + IL_00d4: add + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: ldc.i4.1 + IL_00ee: add + IL_00ef: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_011f: stloc.0 + IL_0120: ldloc.0 + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0139: stloc.0 + IL_013a: ldloc.0 + IL_013b: ldc.i4.1 + IL_013c: add + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0152: dup + IL_0153: ldind.i4 + IL_0154: stloc.0 + IL_0155: ldloc.0 + IL_0156: ldc.i4.1 + IL_0157: add + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: add + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_017e: dup + IL_017f: ldind.i4 + IL_0180: stloc.0 + IL_0181: ldloc.0 + IL_0182: ldc.i4.1 + IL_0183: add + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::IntPostIncTest + + .method public hidebysig static void IntPreIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 396 (0x18c) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: ldc.i4.1 + IL_0018: add + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: ldc.i4.1 + IL_002c: add + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: ldc.i4.1 + IL_0042: add + IL_0043: stloc.0 + IL_0044: ldloc.0 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0057: dup + IL_0058: ldind.i4 + IL_0059: ldc.i4.1 + IL_005a: add + IL_005b: stloc.0 + IL_005c: ldloc.0 + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006c: ldc.i4.1 + IL_006d: add + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0086: ldc.i4.1 + IL_0087: add + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a0: ldc.i4.1 + IL_00a1: add + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00b9: dup + IL_00ba: ldind.i4 + IL_00bb: ldc.i4.1 + IL_00bc: add + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00d1: ldc.i4.1 + IL_00d2: add + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00eb: ldc.i4.1 + IL_00ec: add + IL_00ed: stloc.0 + IL_00ee: ldloc.0 + IL_00ef: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: stloc.0 + IL_0108: ldloc.0 + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_011f: ldc.i4.1 + IL_0120: add + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0139: ldc.i4.1 + IL_013a: add + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0152: dup + IL_0153: ldind.i4 + IL_0154: ldc.i4.1 + IL_0155: add + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_016a: ldc.i4.1 + IL_016b: add + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_017e: dup + IL_017f: ldind.i4 + IL_0180: ldc.i4.1 + IL_0181: add + IL_0182: stloc.0 + IL_0183: ldloc.0 + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::IntPreIncTest - .method public hidebysig instance void - Int32_Local_Div(int32 i) cil managed + .method public hidebysig static void IntPostDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: div - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: div - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Div + // Code size 396 (0x18c) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: stloc.0 + IL_002c: ldloc.0 + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: stloc.0 + IL_0042: ldloc.0 + IL_0043: ldc.i4.1 + IL_0044: sub + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0057: dup + IL_0058: ldind.i4 + IL_0059: stloc.0 + IL_005a: ldloc.0 + IL_005b: ldc.i4.1 + IL_005c: sub + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: ldc.i4.1 + IL_006f: sub + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0086: stloc.0 + IL_0087: ldloc.0 + IL_0088: ldc.i4.1 + IL_0089: sub + IL_008a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: ldc.i4.1 + IL_00a3: sub + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00b9: dup + IL_00ba: ldind.i4 + IL_00bb: stloc.0 + IL_00bc: ldloc.0 + IL_00bd: ldc.i4.1 + IL_00be: sub + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00d1: stloc.0 + IL_00d2: ldloc.0 + IL_00d3: ldc.i4.1 + IL_00d4: sub + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: ldc.i4.1 + IL_00ee: sub + IL_00ef: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_011f: stloc.0 + IL_0120: ldloc.0 + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0139: stloc.0 + IL_013a: ldloc.0 + IL_013b: ldc.i4.1 + IL_013c: sub + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0152: dup + IL_0153: ldind.i4 + IL_0154: stloc.0 + IL_0155: ldloc.0 + IL_0156: ldc.i4.1 + IL_0157: sub + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: sub + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_017e: dup + IL_017f: ldind.i4 + IL_0180: stloc.0 + IL_0181: ldloc.0 + IL_0182: ldc.i4.1 + IL_0183: sub + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::IntPostDecTest - .method public hidebysig instance void - Int32_Local_Rem(int32 i) cil managed + .method public hidebysig static void IntPreDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: rem - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: rem - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_Rem + // Code size 396 (0x18c) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: dup + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0017: ldc.i4.1 + IL_0018: sub + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002b: ldc.i4.1 + IL_002c: sub + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0041: ldc.i4.1 + IL_0042: sub + IL_0043: stloc.0 + IL_0044: ldloc.0 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0057: dup + IL_0058: ldind.i4 + IL_0059: ldc.i4.1 + IL_005a: sub + IL_005b: stloc.0 + IL_005c: ldloc.0 + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_006c: ldc.i4.1 + IL_006d: sub + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0086: ldc.i4.1 + IL_0087: sub + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00a0: ldc.i4.1 + IL_00a1: sub + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00b9: dup + IL_00ba: ldind.i4 + IL_00bb: ldc.i4.1 + IL_00bc: sub + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00d1: ldc.i4.1 + IL_00d2: sub + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00eb: ldc.i4.1 + IL_00ec: sub + IL_00ed: stloc.0 + IL_00ee: ldloc.0 + IL_00ef: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: stloc.0 + IL_0108: ldloc.0 + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_011f: ldc.i4.1 + IL_0120: sub + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0139: ldc.i4.1 + IL_013a: sub + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0152: dup + IL_0153: ldind.i4 + IL_0154: ldc.i4.1 + IL_0155: sub + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_016a: ldc.i4.1 + IL_016b: sub + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_017e: dup + IL_017f: ldind.i4 + IL_0180: ldc.i4.1 + IL_0181: sub + IL_0182: stloc.0 + IL_0183: ldloc.0 + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::IntPreDecTest - .method public hidebysig instance void - Int32_Local_BitAnd(int32 i) cil managed + .method public hidebysig static void UintAddTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: and - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: and - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: add + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: add + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: add + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: add + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: add + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: add + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: add + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: add + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: add + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: add + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: add + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: add + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: add + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: add + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: add + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: add + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintAddTest - .method public hidebysig instance void - Int32_Local_BitOr(int32 i) cil managed + .method public hidebysig static void UintSubtractTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: or - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: or - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitOr + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: sub + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: sub + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: sub + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: sub + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: sub + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: sub + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: sub + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: sub + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: sub + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: sub + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: sub + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: sub + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: sub + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: sub + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: sub + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: sub + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintSubtractTest - .method public hidebysig instance void - Int32_Local_BitXor(int32 i) cil managed + .method public hidebysig static void UintMultiplyTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: xor - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: xor - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitXor + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: mul + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: mul + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: mul + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: mul + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: mul + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: mul + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: mul + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: mul + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: mul + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: mul + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: mul + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: mul + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: mul + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: mul + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: mul + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: mul + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: mul + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintMultiplyTest - .method public hidebysig instance void - Int32_Local_ShiftLeft(int32 i) cil managed + .method public hidebysig static void UintDivideTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: shl - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: shl - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: div.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: div.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: div.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: div.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: div.un + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: div.un + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: div.un + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: div.un + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: div.un + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: div.un + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: div.un + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: div.un + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: div.un + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: div.un + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: div.un + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: div.un + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: div.un + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintDivideTest - .method public hidebysig instance void - Int32_Local_ShiftRight(int32 i) cil managed + .method public hidebysig static void UintModulusTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: shr - IL_0003: starg.s i - IL_0005: ldarg.1 - IL_0006: ldc.i4.5 - IL_0007: shr - IL_0008: dup - IL_0009: starg.s i - IL_000b: call void [mscorlib]System.Console::WriteLine(int32) - IL_0010: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: rem.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: rem.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: rem.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: rem.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: rem.un + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: rem.un + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: rem.un + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: rem.un + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: rem.un + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: rem.un + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: rem.un + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: rem.un + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: rem.un + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: rem.un + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: rem.un + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: rem.un + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: rem.un + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintModulusTest - .method public hidebysig instance void - IntegerWithInline(int32 i) cil managed + .method public hidebysig static void UintLeftShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldc.i4.5 - IL_0002: add - IL_0003: dup - IL_0004: starg.s i - IL_0006: call void [mscorlib]System.Console::WriteLine(int32) - IL_000b: ldarg.1 - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: ret - } // end of method CompoundAssignmentTest::IntegerWithInline + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: shl + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: shl + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: shl + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: shl + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: shl + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: shl + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: shl + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: shl + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: shl + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: shl + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintLeftShiftTest - .method public hidebysig instance void - IntegerField(int32 i) cil managed + .method public hidebysig static void UintRightShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 67 (0x43) + // Code size 264 (0x108) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: ldarg.0 - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0007: ldarg.1 - IL_0008: add - IL_0009: dup - IL_000a: stloc.0 - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0010: ldloc.0 - IL_0011: call void [mscorlib]System.Console::WriteLine(int32) - IL_0016: ldarg.0 - IL_0017: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_001c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0021: ldarg.0 - IL_0022: ldarg.0 - IL_0023: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0028: ldarg.1 - IL_0029: sub - IL_002a: dup - IL_002b: stloc.0 - IL_002c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0031: ldloc.0 - IL_0032: call void [mscorlib]System.Console::WriteLine(int32) - IL_0037: ldarg.0 - IL_0038: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_003d: call void [mscorlib]System.Console::WriteLine(int32) - IL_0042: ret - } // end of method CompoundAssignmentTest::IntegerField + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: shr.un + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: shr.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: shr.un + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: shr.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: shr.un + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: shr.un + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: shr.un + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: shr.un + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: shr.un + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: shr.un + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: shr.un + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: shr.un + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: shr.un + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: shr.un + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: shr.un + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: shr.un + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: shr.un + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintRightShiftTest - .method public hidebysig instance void - Array(int32 i) cil managed + .method public hidebysig static void UintBitAndTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 55 (0x37) - .maxstack 4 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0006: ldarg.1 - IL_0007: ldelema [mscorlib]System.Int32 - IL_000c: dup - IL_000d: ldind.i4 - IL_000e: ldarg.1 - IL_000f: add - IL_0010: dup - IL_0011: stloc.0 - IL_0012: stind.i4 - IL_0013: ldloc.0 - IL_0014: call void [mscorlib]System.Console::WriteLine(int32) - IL_0019: ldarg.0 - IL_001a: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_001f: ldarg.1 - IL_0020: ldc.i4.2 - IL_0021: mul - IL_0022: ldelema [mscorlib]System.Int32 + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: and + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: and + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: and + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 IL_0027: dup - IL_0028: ldind.i4 - IL_0029: ldarg.1 - IL_002a: ldc.i4.2 - IL_002b: mul - IL_002c: add - IL_002d: dup - IL_002e: stloc.0 - IL_002f: stind.i4 - IL_0030: ldloc.0 - IL_0031: call void [mscorlib]System.Console::WriteLine(int32) - IL_0036: ret - } // end of method CompoundAssignmentTest::Array + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: and + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: and + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: and + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: and + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: and + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: and + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: and + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: and + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: and + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: and + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: and + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: and + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: and + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: and + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintBitAndTest - .method public hidebysig instance int32 - ArrayUsageWithMethods() cil managed + .method public hidebysig static void UintBitOrTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 26 (0x1a) + // Code size 264 (0x108) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() - IL_0006: ldarg.0 - IL_0007: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() - IL_000c: ldelema [mscorlib]System.Int32 - IL_0011: dup - IL_0012: ldind.i4 - IL_0013: stloc.0 - IL_0014: ldloc.0 - IL_0015: ldc.i4.1 - IL_0016: add - IL_0017: stind.i4 - IL_0018: ldloc.0 - IL_0019: ret - } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: or + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: or + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: or + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: or + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: or + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: or + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: or + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: or + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: or + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: or + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: or + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: or + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: or + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: or + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: or + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: or + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: or + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintBitOrTest + + .method public hidebysig static void UintBitXorTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.5 + IL_0006: xor + IL_0007: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000c: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0011: ldc.i4.5 + IL_0012: xor + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_001f: ldc.i4.5 + IL_0020: xor + IL_0021: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002d: ldc.i4.5 + IL_002e: xor + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0034: ldarga.s s + IL_0036: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003b: dup + IL_003c: ldind.u4 + IL_003d: ldc.i4.5 + IL_003e: xor + IL_003f: stind.i4 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0048: ldc.i4.5 + IL_0049: xor + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005a: ldc.i4.5 + IL_005b: xor + IL_005c: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_006c: ldc.i4.5 + IL_006d: xor + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_007d: dup + IL_007e: ldind.u4 + IL_007f: ldc.i4.5 + IL_0080: xor + IL_0081: stind.i4 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_008d: ldc.i4.5 + IL_008e: xor + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_009f: ldc.i4.5 + IL_00a0: xor + IL_00a1: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b1: ldc.i4.5 + IL_00b2: xor + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00c3: ldc.i4.5 + IL_00c4: xor + IL_00c5: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00d5: ldc.i4.5 + IL_00d6: xor + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00e6: dup + IL_00e7: ldind.u4 + IL_00e8: ldc.i4.5 + IL_00e9: xor + IL_00ea: stind.i4 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00f6: ldc.i4.5 + IL_00f7: xor + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00fd: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0102: dup + IL_0103: ldind.u4 + IL_0104: ldc.i4.5 + IL_0105: xor + IL_0106: stind.i4 + IL_0107: ret + } // end of method CompoundAssignmentTest::UintBitXorTest - .method public hidebysig instance void - NestedField() cil managed + .method public hidebysig static void UintPostIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 78 (0x4e) + // Code size 396 (0x18c) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0006: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex - IL_000b: brfalse.s IL_004d + .locals init (uint32 V_0) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: add + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: stloc.0 + IL_002c: ldloc.0 + IL_002d: ldc.i4.1 + IL_002e: add + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: stloc.0 + IL_0042: ldloc.0 + IL_0043: ldc.i4.1 + IL_0044: add + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0057: dup + IL_0058: ldind.u4 + IL_0059: stloc.0 + IL_005a: ldloc.0 + IL_005b: ldc.i4.1 + IL_005c: add + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: ldc.i4.1 + IL_006f: add + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0086: stloc.0 + IL_0087: ldloc.0 + IL_0088: ldc.i4.1 + IL_0089: add + IL_008a: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: ldc.i4.1 + IL_00a3: add + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00b9: dup + IL_00ba: ldind.u4 + IL_00bb: stloc.0 + IL_00bc: ldloc.0 + IL_00bd: ldc.i4.1 + IL_00be: add + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00d1: stloc.0 + IL_00d2: ldloc.0 + IL_00d3: ldc.i4.1 + IL_00d4: add + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: ldc.i4.1 + IL_00ee: add + IL_00ef: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_011f: stloc.0 + IL_0120: ldloc.0 + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0139: stloc.0 + IL_013a: ldloc.0 + IL_013b: ldc.i4.1 + IL_013c: add + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0152: dup + IL_0153: ldind.u4 + IL_0154: stloc.0 + IL_0155: ldloc.0 + IL_0156: ldc.i4.1 + IL_0157: add + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: add + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_017e: dup + IL_017f: ldind.u4 + IL_0180: stloc.0 + IL_0181: ldloc.0 + IL_0182: ldc.i4.1 + IL_0183: add + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::UintPostIncTest - IL_000d: ldarg.0 - IL_000e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0013: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0018: dup - IL_0019: ldind.i4 - IL_001a: ldc.i4.2 - IL_001b: mul - IL_001c: dup - IL_001d: stloc.0 - IL_001e: stind.i4 - IL_001f: ldloc.0 - IL_0020: call void [mscorlib]System.Console::WriteLine(int32) - IL_0025: ldarg.0 - IL_0026: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_002b: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0030: dup - IL_0031: ldind.i4 - IL_0032: ldc.i4.1 - IL_0033: add - IL_0034: stind.i4 - IL_0035: ldarg.0 - IL_0036: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_003b: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0040: dup - IL_0041: ldind.i4 - IL_0042: stloc.0 - IL_0043: ldloc.0 - IL_0044: ldc.i4.1 - IL_0045: add - IL_0046: stind.i4 - IL_0047: ldloc.0 - IL_0048: call void [mscorlib]System.Console::WriteLine(int32) - IL_004d: ret - } // end of method CompoundAssignmentTest::NestedField + .method public hidebysig static void UintPreIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 396 (0x18c) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.1 + IL_0006: add + IL_0007: dup + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: ldc.i4.1 + IL_0018: add + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: ldc.i4.1 + IL_002c: add + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: ldc.i4.1 + IL_0042: add + IL_0043: stloc.0 + IL_0044: ldloc.0 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0057: dup + IL_0058: ldind.u4 + IL_0059: ldc.i4.1 + IL_005a: add + IL_005b: stloc.0 + IL_005c: ldloc.0 + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006c: ldc.i4.1 + IL_006d: add + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0086: ldc.i4.1 + IL_0087: add + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a0: ldc.i4.1 + IL_00a1: add + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00b9: dup + IL_00ba: ldind.u4 + IL_00bb: ldc.i4.1 + IL_00bc: add + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00d1: ldc.i4.1 + IL_00d2: add + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00eb: ldc.i4.1 + IL_00ec: add + IL_00ed: stloc.0 + IL_00ee: ldloc.0 + IL_00ef: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: stloc.0 + IL_0108: ldloc.0 + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_011f: ldc.i4.1 + IL_0120: add + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0139: ldc.i4.1 + IL_013a: add + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0152: dup + IL_0153: ldind.u4 + IL_0154: ldc.i4.1 + IL_0155: add + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_016a: ldc.i4.1 + IL_016b: add + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_017e: dup + IL_017f: ldind.u4 + IL_0180: ldc.i4.1 + IL_0181: add + IL_0182: stloc.0 + IL_0183: ldloc.0 + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::UintPreIncTest - .method public hidebysig instance void - Enum() cil managed + .method public hidebysig static void UintPostDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 58 (0x3a) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldarg.0 - IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0007: ldc.i4.2 - IL_0008: or - IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_000e: ldarg.0 - IL_000f: ldarg.0 - IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0015: ldc.i4.s -5 - IL_0017: and - IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_001d: ldarg.0 - IL_001e: ldarg.0 - IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0024: ldc.i4.2 - IL_0025: add - IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_002b: ldarg.0 - IL_002c: ldarg.0 - IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0032: ldc.i4.3 - IL_0033: sub - IL_0034: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0039: ret - } // end of method CompoundAssignmentTest::Enum + // Code size 396 (0x18c) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: dup + IL_0018: ldc.i4.1 + IL_0019: sub + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: stloc.0 + IL_002c: ldloc.0 + IL_002d: ldc.i4.1 + IL_002e: sub + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: stloc.0 + IL_0042: ldloc.0 + IL_0043: ldc.i4.1 + IL_0044: sub + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0057: dup + IL_0058: ldind.u4 + IL_0059: stloc.0 + IL_005a: ldloc.0 + IL_005b: ldc.i4.1 + IL_005c: sub + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: ldc.i4.1 + IL_006f: sub + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0086: stloc.0 + IL_0087: ldloc.0 + IL_0088: ldc.i4.1 + IL_0089: sub + IL_008a: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: ldc.i4.1 + IL_00a3: sub + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00b9: dup + IL_00ba: ldind.u4 + IL_00bb: stloc.0 + IL_00bc: ldloc.0 + IL_00bd: ldc.i4.1 + IL_00be: sub + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00d1: stloc.0 + IL_00d2: ldloc.0 + IL_00d3: ldc.i4.1 + IL_00d4: sub + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: ldc.i4.1 + IL_00ee: sub + IL_00ef: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_011f: stloc.0 + IL_0120: ldloc.0 + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0139: stloc.0 + IL_013a: ldloc.0 + IL_013b: ldc.i4.1 + IL_013c: sub + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0152: dup + IL_0153: ldind.u4 + IL_0154: stloc.0 + IL_0155: ldloc.0 + IL_0156: ldc.i4.1 + IL_0157: sub + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: sub + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_017e: dup + IL_017f: ldind.u4 + IL_0180: stloc.0 + IL_0181: ldloc.0 + IL_0182: ldc.i4.1 + IL_0183: sub + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::UintPostDecTest - .method public hidebysig instance void - ShortEnumTest() cil managed + .method public hidebysig static void UintPreDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 59 (0x3b) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: ldarg.0 - IL_0002: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0007: ldc.i4.2 - IL_0008: or - IL_0009: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_000e: ldarg.0 - IL_000f: ldarg.0 - IL_0010: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0015: ldc.i4.4 - IL_0016: and - IL_0017: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_001c: ldarg.0 - IL_001d: ldarg.0 - IL_001e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0023: ldc.i4.2 - IL_0024: add - IL_0025: conv.i2 - IL_0026: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_002b: ldarg.0 - IL_002c: ldarg.0 - IL_002d: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0032: ldc.i4.3 - IL_0033: sub - IL_0034: conv.i2 - IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_003a: ret - } // end of method CompoundAssignmentTest::ShortEnumTest + // Code size 396 (0x18c) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0005: ldc.i4.1 + IL_0006: sub + IL_0007: dup + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0012: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0017: ldc.i4.1 + IL_0018: sub + IL_0019: dup + IL_001a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_001f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0024: ldarg.1 + IL_0025: dup + IL_0026: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002b: ldc.i4.1 + IL_002c: sub + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0034: ldloc.0 + IL_0035: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003a: ldarg.1 + IL_003b: dup + IL_003c: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0041: ldc.i4.1 + IL_0042: sub + IL_0043: stloc.0 + IL_0044: ldloc.0 + IL_0045: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004a: ldloc.0 + IL_004b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0050: ldarga.s s + IL_0052: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0057: dup + IL_0058: ldind.u4 + IL_0059: ldc.i4.1 + IL_005a: sub + IL_005b: stloc.0 + IL_005c: ldloc.0 + IL_005d: stind.i4 + IL_005e: ldloc.0 + IL_005f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0064: ldarga.s s + IL_0066: dup + IL_0067: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_006c: ldc.i4.1 + IL_006d: sub + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0080: dup + IL_0081: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0086: ldc.i4.1 + IL_0087: sub + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00a0: ldc.i4.1 + IL_00a1: sub + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00a9: ldloc.0 + IL_00aa: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00af: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b4: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00b9: dup + IL_00ba: ldind.u4 + IL_00bb: ldc.i4.1 + IL_00bc: sub + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: stind.i4 + IL_00c0: ldloc.0 + IL_00c1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cb: dup + IL_00cc: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00d1: ldc.i4.1 + IL_00d2: sub + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00da: ldloc.0 + IL_00db: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e5: dup + IL_00e6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00eb: ldc.i4.1 + IL_00ec: sub + IL_00ed: stloc.0 + IL_00ee: ldloc.0 + IL_00ef: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00f4: ldloc.0 + IL_00f5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: stloc.0 + IL_0108: ldloc.0 + IL_0109: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_010e: ldloc.0 + IL_010f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0114: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0119: dup + IL_011a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_011f: ldc.i4.1 + IL_0120: sub + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0128: ldloc.0 + IL_0129: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0133: dup + IL_0134: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0139: ldc.i4.1 + IL_013a: sub + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0152: dup + IL_0153: ldind.u4 + IL_0154: ldc.i4.1 + IL_0155: sub + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: stind.i4 + IL_0159: ldloc.0 + IL_015a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0164: dup + IL_0165: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_016a: ldc.i4.1 + IL_016b: sub + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0173: ldloc.0 + IL_0174: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0179: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_017e: dup + IL_017f: ldind.u4 + IL_0180: ldc.i4.1 + IL_0181: sub + IL_0182: stloc.0 + IL_0183: ldloc.0 + IL_0184: stind.i4 + IL_0185: ldloc.0 + IL_0186: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018b: ret + } // end of method CompoundAssignmentTest::UintPreDecTest - .method public hidebysig instance int32 - PreIncrementInAddition(int32 i, - int32 j) cil managed + .method public hidebysig static void LongAddTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 9 (0x9) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldc.i4.1 - IL_0003: add - IL_0004: dup - IL_0005: starg.s j + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 IL_0007: add - IL_0008: ret - } // end of method CompoundAssignmentTest::PreIncrementInAddition + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: add + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: add + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: add + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: add + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: add + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: add + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: add + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: add + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: add + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: add + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: add + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: add + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: add + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: add + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: add + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: add + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongAddTest - .method public hidebysig instance int32 - PreIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongSubtractTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 16 (0x10) + // Code size 281 (0x119) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldind.i4 - IL_0009: ldc.i4.1 - IL_000a: sub - IL_000b: stloc.0 - IL_000c: ldloc.0 - IL_000d: stind.i4 - IL_000e: ldloc.0 - IL_000f: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElement + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: sub + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: sub + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: sub + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: sub + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: sub + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: sub + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: sub + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: sub + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: sub + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: sub + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: sub + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: sub + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: sub + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: sub + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: sub + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: sub + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongSubtractTest - .method public hidebysig instance int32 - PostIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongMultiplyTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 16 (0x10) + // Code size 281 (0x119) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldind.i4 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: add - IL_000d: stind.i4 - IL_000e: ldloc.0 - IL_000f: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElement + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: mul + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: mul + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: mul + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: mul + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: mul + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: mul + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: mul + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: mul + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: mul + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: mul + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: mul + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: mul + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: mul + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: mul + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: mul + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: mul + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: mul + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongMultiplyTest - .method public hidebysig instance void - IncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongDivideTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldind.i4 - IL_0009: ldc.i4.1 - IL_000a: add - IL_000b: stind.i4 - IL_000c: ret - } // end of method CompoundAssignmentTest::IncrementArrayElement + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: div + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: div + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: div + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: div + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: div + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: div + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: div + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: div + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: div + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: div + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: div + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: div + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: div + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: div + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: div + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: div + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: div + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongDivideTest - .method public hidebysig instance void - DoubleArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongModulusTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldind.i4 - IL_0009: ldc.i4.2 - IL_000a: mul - IL_000b: stind.i4 - IL_000c: ret - } // end of method CompoundAssignmentTest::DoubleArrayElement + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: rem + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: rem + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: rem + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: rem + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: rem + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: rem + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: rem + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: rem + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: rem + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: rem + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: rem + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: rem + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: rem + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: rem + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: rem + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: rem + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: rem + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongModulusTest - .method public hidebysig instance int32 - DoubleArrayElementAndReturn(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongLeftShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 16 (0x10) + // Code size 264 (0x108) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int32 - IL_0007: dup - IL_0008: ldind.i4 - IL_0009: ldc.i4.2 - IL_000a: mul - IL_000b: dup - IL_000c: stloc.0 - IL_000d: stind.i4 - IL_000e: ldloc.0 - IL_000f: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000c: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0034: ldarga.s s + IL_0036: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003b: dup + IL_003c: ldind.i8 + IL_003d: ldc.i4.5 + IL_003e: shl + IL_003f: stind.i8 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0048: ldc.i4.5 + IL_0049: shl + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005a: ldc.i4.5 + IL_005b: shl + IL_005c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_006c: ldc.i4.5 + IL_006d: shl + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_007d: dup + IL_007e: ldind.i8 + IL_007f: ldc.i4.5 + IL_0080: shl + IL_0081: stind.i8 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_008d: ldc.i4.5 + IL_008e: shl + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009f: ldc.i4.5 + IL_00a0: shl + IL_00a1: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b1: ldc.i4.5 + IL_00b2: shl + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00c3: ldc.i4.5 + IL_00c4: shl + IL_00c5: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00e6: dup + IL_00e7: ldind.i8 + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: stind.i8 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00fd: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0102: dup + IL_0103: ldind.i8 + IL_0104: ldc.i4.5 + IL_0105: shl + IL_0106: stind.i8 + IL_0107: ret + } // end of method CompoundAssignmentTest::LongLeftShiftTest - .method public hidebysig instance int32 - PreIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongRightShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: shr + IL_0007: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000c: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0011: ldc.i4.5 + IL_0012: shr + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_001f: ldc.i4.5 + IL_0020: shr + IL_0021: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002d: ldc.i4.5 + IL_002e: shr + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0034: ldarga.s s + IL_0036: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003b: dup + IL_003c: ldind.i8 + IL_003d: ldc.i4.5 + IL_003e: shr + IL_003f: stind.i8 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0048: ldc.i4.5 + IL_0049: shr + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005a: ldc.i4.5 + IL_005b: shr + IL_005c: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_006c: ldc.i4.5 + IL_006d: shr + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_007d: dup + IL_007e: ldind.i8 + IL_007f: ldc.i4.5 + IL_0080: shr + IL_0081: stind.i8 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_008d: ldc.i4.5 + IL_008e: shr + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_009f: ldc.i4.5 + IL_00a0: shr + IL_00a1: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b1: ldc.i4.5 + IL_00b2: shr + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00c3: ldc.i4.5 + IL_00c4: shr + IL_00c5: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00d5: ldc.i4.5 + IL_00d6: shr + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00e6: dup + IL_00e7: ldind.i8 + IL_00e8: ldc.i4.5 + IL_00e9: shr + IL_00ea: stind.i8 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00f6: ldc.i4.5 + IL_00f7: shr + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00fd: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0102: dup + IL_0103: ldind.i8 + IL_0104: ldc.i4.5 + IL_0105: shr + IL_0106: stind.i8 + IL_0107: ret + } // end of method CompoundAssignmentTest::LongRightShiftTest + + .method public hidebysig static void LongBitAndTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: and + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: and + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: and + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: and + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: and + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: and + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: and + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: and + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: and + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: and + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: and + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: and + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: and + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: and + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: and + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: and + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: and + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongBitAndTest + + .method public hidebysig static void LongBitOrTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) + // Code size 281 (0x119) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldind.i2 - IL_0009: ldc.i4.1 - IL_000a: sub - IL_000b: conv.i2 - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: stind.i2 - IL_000f: ldloc.0 - IL_0010: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: or + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: or + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: or + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: or + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: or + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: or + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: or + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: or + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: or + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: or + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: or + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: or + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: or + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: or + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: or + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: or + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: or + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongBitOrTest - .method public hidebysig instance int32 - PostIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongBitXorTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) + // Code size 281 (0x119) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldind.i2 - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: ldc.i4.1 - IL_000c: add - IL_000d: conv.i2 - IL_000e: stind.i2 - IL_000f: ldloc.0 - IL_0010: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: xor + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: xor + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: xor + IL_0024: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: xor + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0038: ldarga.s s + IL_003a: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: xor + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: xor + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: xor + IL_0063: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: xor + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: xor + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: xor + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: xor + IL_00ac: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: xor + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: xor + IL_00d2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: xor + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: xor + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: xor + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_010d: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: xor + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::LongBitXorTest - .method public hidebysig instance void - IncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPostIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldind.i2 - IL_0009: ldc.i4.1 - IL_000a: add - IL_000b: conv.i2 - IL_000c: stind.i2 - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementArrayElementShort + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int64 V_0) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: add + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: add + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: conv.i8 + IL_0061: add + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: conv.i8 + IL_0075: add + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: conv.i8 + IL_0090: add + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: conv.i8 + IL_00ab: add + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: conv.i8 + IL_00c7: add + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: conv.i8 + IL_00de: add + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: conv.i8 + IL_00f9: add + IL_00fa: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: conv.i8 + IL_0114: add + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: conv.i8 + IL_012f: add + IL_0130: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: conv.i8 + IL_014a: add + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: conv.i8 + IL_0166: add + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: conv.i8 + IL_017d: add + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: add + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::LongPostIncTest - .method public hidebysig instance void - DoubleArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPreIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldind.i2 - IL_0009: ldc.i4.2 - IL_000a: mul - IL_000b: conv.i2 - IL_000c: stind.i2 - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShort + // Code size 413 (0x19d) + .maxstack 3 + .locals init (int64 V_0) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: add + IL_0008: dup + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: add + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: add + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: ldc.i4.1 + IL_005e: conv.i8 + IL_005f: add + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0071: ldc.i4.1 + IL_0072: conv.i8 + IL_0073: add + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008c: ldc.i4.1 + IL_008d: conv.i8 + IL_008e: add + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00a7: ldc.i4.1 + IL_00a8: conv.i8 + IL_00a9: add + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: ldc.i4.1 + IL_00c4: conv.i8 + IL_00c5: add + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00da: ldc.i4.1 + IL_00db: conv.i8 + IL_00dc: add + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00f5: ldc.i4.1 + IL_00f6: conv.i8 + IL_00f7: add + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0110: ldc.i4.1 + IL_0111: conv.i8 + IL_0112: add + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_012b: ldc.i4.1 + IL_012c: conv.i8 + IL_012d: add + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: add + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: add + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0179: ldc.i4.1 + IL_017a: conv.i8 + IL_017b: add + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: add + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::LongPreIncTest - .method public hidebysig instance int16 - DoubleArrayElementShortAndReturn(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongPostDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 17 (0x11) + // Code size 413 (0x19d) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.1 - IL_0001: ldarg.2 - IL_0002: ldelema [mscorlib]System.Int16 - IL_0007: dup - IL_0008: ldind.i2 - IL_0009: ldc.i4.2 - IL_000a: mul - IL_000b: conv.i2 - IL_000c: dup - IL_000d: stloc.0 - IL_000e: stind.i2 - IL_000f: ldloc.0 - IL_0010: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + .locals init (int64 V_0) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: sub + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: sub + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: conv.i8 + IL_0061: sub + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: conv.i8 + IL_0075: sub + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: conv.i8 + IL_0090: sub + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: conv.i8 + IL_00ab: sub + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: conv.i8 + IL_00c7: sub + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: conv.i8 + IL_00de: sub + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: conv.i8 + IL_00f9: sub + IL_00fa: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: conv.i8 + IL_0114: sub + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: conv.i8 + IL_012f: sub + IL_0130: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: conv.i8 + IL_014a: sub + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: conv.i8 + IL_0166: sub + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: conv.i8 + IL_017d: sub + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: sub + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::LongPostDecTest - .method public hidebysig instance int32 - PreIncrementInstanceField() cil managed + .method public hidebysig static void LongPreDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 413 (0x19d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: stloc.0 - IL_000f: ldloc.0 - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField + .locals init (int64 V_0) + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: dup + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: sub + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: ldc.i4.1 + IL_005e: conv.i8 + IL_005f: sub + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0071: ldc.i4.1 + IL_0072: conv.i8 + IL_0073: sub + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_008c: ldc.i4.1 + IL_008d: conv.i8 + IL_008e: sub + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00a7: ldc.i4.1 + IL_00a8: conv.i8 + IL_00a9: sub + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: ldc.i4.1 + IL_00c4: conv.i8 + IL_00c5: sub + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00da: ldc.i4.1 + IL_00db: conv.i8 + IL_00dc: sub + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00f5: ldc.i4.1 + IL_00f6: conv.i8 + IL_00f7: sub + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0110: ldc.i4.1 + IL_0111: conv.i8 + IL_0112: sub + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_012b: ldc.i4.1 + IL_012c: conv.i8 + IL_012d: sub + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: sub + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: sub + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0179: ldc.i4.1 + IL_017a: conv.i8 + IL_017b: sub + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: sub + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::LongPreDecTest - .method public hidebysig instance int32 - PostIncrementInstanceField() cil managed + .method public hidebysig static void UlongAddTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 281 (0x119) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: add + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: add + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: add + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: add + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: add + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: add + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: add + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: add + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: add + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: add + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: add + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: add + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: add + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: add + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: add + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: add + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: add + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongAddTest - .method public hidebysig instance void - IncrementInstanceField() cil managed + .method public hidebysig static void UlongSubtractTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0013: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: sub + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: sub + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: sub + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: sub + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: sub + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: sub + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: sub + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: sub + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: sub + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: sub + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: sub + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: sub + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: sub + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: sub + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: sub + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: sub + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongSubtractTest - .method public hidebysig instance void - DoubleInstanceField() cil managed + .method public hidebysig static void UlongMultiplyTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleInstanceField + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: mul + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: mul + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: mul + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: mul + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: mul + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: mul + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: mul + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: mul + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: mul + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: mul + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: mul + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: mul + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: mul + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: mul + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: mul + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: mul + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: mul + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongMultiplyTest - .method public hidebysig instance int32 - DoubleInstanceFieldAndReturn() cil managed + .method public hidebysig static void UlongDivideTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 281 (0x119) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: dup - IL_000f: stloc.0 - IL_0010: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: div.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: div.un + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: div.un + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: div.un + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: div.un + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: div.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: div.un + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: div.un + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: div.un + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: div.un + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: div.un + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: div.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: div.un + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: div.un + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: div.un + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: div.un + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: div.un + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongDivideTest - .method public hidebysig instance int32 - PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongModulusTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) + // Code size 281 (0x119) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: stloc.0 - IL_000a: ldloc.0 - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0010: ldloc.0 - IL_0011: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: rem.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: rem.un + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: rem.un + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: rem.un + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: rem.un + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: rem.un + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: rem.un + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: rem.un + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: rem.un + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: rem.un + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: rem.un + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: rem.un + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: rem.un + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: rem.un + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: rem.un + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: rem.un + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: rem.un + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongModulusTest - .method public hidebysig instance int32 - PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongLeftShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 18 (0x12) + // Code size 264 (0x108) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: stloc.0 - IL_0008: ldloc.0 - IL_0009: ldc.i4.1 - IL_000a: add - IL_000b: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0010: ldloc.0 - IL_0011: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: shl + IL_0007: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000c: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0011: ldc.i4.5 + IL_0012: shl + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_001f: ldc.i4.5 + IL_0020: shl + IL_0021: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002d: ldc.i4.5 + IL_002e: shl + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0034: ldarga.s s + IL_0036: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003b: dup + IL_003c: ldind.i8 + IL_003d: ldc.i4.5 + IL_003e: shl + IL_003f: stind.i8 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0048: ldc.i4.5 + IL_0049: shl + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005a: ldc.i4.5 + IL_005b: shl + IL_005c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_006c: ldc.i4.5 + IL_006d: shl + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_007d: dup + IL_007e: ldind.i8 + IL_007f: ldc.i4.5 + IL_0080: shl + IL_0081: stind.i8 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_008d: ldc.i4.5 + IL_008e: shl + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009f: ldc.i4.5 + IL_00a0: shl + IL_00a1: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b1: ldc.i4.5 + IL_00b2: shl + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00c3: ldc.i4.5 + IL_00c4: shl + IL_00c5: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00d5: ldc.i4.5 + IL_00d6: shl + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00e6: dup + IL_00e7: ldind.i8 + IL_00e8: ldc.i4.5 + IL_00e9: shl + IL_00ea: stind.i8 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00f6: ldc.i4.5 + IL_00f7: shl + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00fd: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0102: dup + IL_0103: ldind.i8 + IL_0104: ldc.i4.5 + IL_0105: shl + IL_0106: stind.i8 + IL_0107: ret + } // end of method CompoundAssignmentTest::UlongLeftShiftTest - .method public hidebysig instance void - IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongRightShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldarg.1 - IL_0001: dup - IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField2 + // Code size 264 (0x108) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: shr.un + IL_0007: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000c: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0011: ldc.i4.5 + IL_0012: shr.un + IL_0013: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0018: ldarg.1 + IL_0019: dup + IL_001a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_001f: ldc.i4.5 + IL_0020: shr.un + IL_0021: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002d: ldc.i4.5 + IL_002e: shr.un + IL_002f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0034: ldarga.s s + IL_0036: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003b: dup + IL_003c: ldind.i8 + IL_003d: ldc.i4.5 + IL_003e: shr.un + IL_003f: stind.i8 + IL_0040: ldarga.s s + IL_0042: dup + IL_0043: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0048: ldc.i4.5 + IL_0049: shr.un + IL_004a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_004f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0054: dup + IL_0055: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005a: ldc.i4.5 + IL_005b: shr.un + IL_005c: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0061: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0066: dup + IL_0067: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_006c: ldc.i4.5 + IL_006d: shr.un + IL_006e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0073: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0078: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_007d: dup + IL_007e: ldind.i8 + IL_007f: ldc.i4.5 + IL_0080: shr.un + IL_0081: stind.i8 + IL_0082: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0087: dup + IL_0088: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_008d: ldc.i4.5 + IL_008e: shr.un + IL_008f: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0094: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0099: dup + IL_009a: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_009f: ldc.i4.5 + IL_00a0: shr.un + IL_00a1: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a6: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ab: dup + IL_00ac: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b1: ldc.i4.5 + IL_00b2: shr.un + IL_00b3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00bd: dup + IL_00be: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00c3: ldc.i4.5 + IL_00c4: shr.un + IL_00c5: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ca: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00cf: dup + IL_00d0: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00d5: ldc.i4.5 + IL_00d6: shr.un + IL_00d7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00dc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e1: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00e6: dup + IL_00e7: ldind.i8 + IL_00e8: ldc.i4.5 + IL_00e9: shr.un + IL_00ea: stind.i8 + IL_00eb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f0: dup + IL_00f1: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00f6: ldc.i4.5 + IL_00f7: shr.un + IL_00f8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00fd: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0102: dup + IL_0103: ldind.i8 + IL_0104: ldc.i4.5 + IL_0105: shr.un + IL_0106: stind.i8 + IL_0107: ret + } // end of method CompoundAssignmentTest::UlongRightShiftTest - .method public hidebysig instance int32 - PreIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongBitAndTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 281 (0x119) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.i2 - IL_000f: stloc.0 - IL_0010: ldloc.0 - IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: and + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: and + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: and + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: and + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: and + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: and + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: and + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: and + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: and + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: and + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: and + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: and + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: and + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: and + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: and + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: and + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: and + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongBitAndTest - .method public hidebysig instance int32 - PostIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongBitOrTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 281 (0x119) .maxstack 3 - .locals init (int16 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.i2 - IL_0011: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: or + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: or + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: or + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: or + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: or + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: or + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: or + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: or + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: or + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: or + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: or + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: or + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: or + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: or + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: or + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: or + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: or + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongBitOrTest - .method public hidebysig instance void - IncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongBitXorTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.i2 - IL_000f: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + // Code size 281 (0x119) + .maxstack 3 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.5 + IL_0006: conv.i8 + IL_0007: xor + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: conv.i8 + IL_0014: xor + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: conv.i8 + IL_0023: xor + IL_0024: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0029: ldarg.1 + IL_002a: dup + IL_002b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0030: ldc.i4.5 + IL_0031: conv.i8 + IL_0032: xor + IL_0033: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0038: ldarga.s s + IL_003a: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003f: dup + IL_0040: ldind.i8 + IL_0041: ldc.i4.5 + IL_0042: conv.i8 + IL_0043: xor + IL_0044: stind.i8 + IL_0045: ldarga.s s + IL_0047: dup + IL_0048: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004d: ldc.i4.5 + IL_004e: conv.i8 + IL_004f: xor + IL_0050: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0055: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005a: dup + IL_005b: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0060: ldc.i4.5 + IL_0061: conv.i8 + IL_0062: xor + IL_0063: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0068: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006d: dup + IL_006e: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0073: ldc.i4.5 + IL_0074: conv.i8 + IL_0075: xor + IL_0076: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0080: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0085: dup + IL_0086: ldind.i8 + IL_0087: ldc.i4.5 + IL_0088: conv.i8 + IL_0089: xor + IL_008a: stind.i8 + IL_008b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0090: dup + IL_0091: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0096: ldc.i4.5 + IL_0097: conv.i8 + IL_0098: xor + IL_0099: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_009e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a3: dup + IL_00a4: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a9: ldc.i4.5 + IL_00aa: conv.i8 + IL_00ab: xor + IL_00ac: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b6: dup + IL_00b7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00bc: ldc.i4.5 + IL_00bd: conv.i8 + IL_00be: xor + IL_00bf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00c4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c9: dup + IL_00ca: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00cf: ldc.i4.5 + IL_00d0: conv.i8 + IL_00d1: xor + IL_00d2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00dc: dup + IL_00dd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e2: ldc.i4.5 + IL_00e3: conv.i8 + IL_00e4: xor + IL_00e5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ea: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ef: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00f4: dup + IL_00f5: ldind.i8 + IL_00f6: ldc.i4.5 + IL_00f7: conv.i8 + IL_00f8: xor + IL_00f9: stind.i8 + IL_00fa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00ff: dup + IL_0100: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0105: ldc.i4.5 + IL_0106: conv.i8 + IL_0107: xor + IL_0108: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_010d: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_0112: dup + IL_0113: ldind.i8 + IL_0114: ldc.i4.5 + IL_0115: conv.i8 + IL_0116: xor + IL_0117: stind.i8 + IL_0118: ret + } // end of method CompoundAssignmentTest::UlongBitXorTest - .method public hidebysig instance int32 - PreIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPostIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 413 (0x19d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: stloc.0 - IL_000f: ldloc.0 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + .locals init (uint64 V_0) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: add + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: add + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: conv.i8 + IL_0061: add + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: conv.i8 + IL_0075: add + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: conv.i8 + IL_0090: add + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: conv.i8 + IL_00ab: add + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: conv.i8 + IL_00c7: add + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: conv.i8 + IL_00de: add + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: conv.i8 + IL_00f9: add + IL_00fa: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: conv.i8 + IL_0114: add + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: conv.i8 + IL_012f: add + IL_0130: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: conv.i8 + IL_014a: add + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: conv.i8 + IL_0166: add + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: conv.i8 + IL_017d: add + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: add + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UlongPostIncTest - .method public hidebysig instance int32 - PostIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPreIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 413 (0x19d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + .locals init (uint64 V_0) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: add + IL_0008: dup + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: add + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: add + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: ldc.i4.1 + IL_005e: conv.i8 + IL_005f: add + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0071: ldc.i4.1 + IL_0072: conv.i8 + IL_0073: add + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008c: ldc.i4.1 + IL_008d: conv.i8 + IL_008e: add + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00a7: ldc.i4.1 + IL_00a8: conv.i8 + IL_00a9: add + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: ldc.i4.1 + IL_00c4: conv.i8 + IL_00c5: add + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00da: ldc.i4.1 + IL_00db: conv.i8 + IL_00dc: add + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00f5: ldc.i4.1 + IL_00f6: conv.i8 + IL_00f7: add + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0110: ldc.i4.1 + IL_0111: conv.i8 + IL_0112: add + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_012b: ldc.i4.1 + IL_012c: conv.i8 + IL_012d: add + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: add + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: add + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0179: ldc.i4.1 + IL_017a: conv.i8 + IL_017b: add + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: add + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UlongPreIncTest - .method public hidebysig instance void - IncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPostDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) + // Code size 413 (0x19d) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementInstanceProperty + .locals init (uint64 V_0) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: dup + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: dup + IL_0019: ldc.i4.1 + IL_001a: conv.i8 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: stloc.0 + IL_002e: ldloc.0 + IL_002f: ldc.i4.1 + IL_0030: conv.i8 + IL_0031: sub + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: stloc.0 + IL_0045: ldloc.0 + IL_0046: ldc.i4.1 + IL_0047: conv.i8 + IL_0048: sub + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: stloc.0 + IL_005e: ldloc.0 + IL_005f: ldc.i4.1 + IL_0060: conv.i8 + IL_0061: sub + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: ldc.i4.1 + IL_0074: conv.i8 + IL_0075: sub + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008c: stloc.0 + IL_008d: ldloc.0 + IL_008e: ldc.i4.1 + IL_008f: conv.i8 + IL_0090: sub + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: ldc.i4.1 + IL_00aa: conv.i8 + IL_00ab: sub + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: stloc.0 + IL_00c4: ldloc.0 + IL_00c5: ldc.i4.1 + IL_00c6: conv.i8 + IL_00c7: sub + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00da: stloc.0 + IL_00db: ldloc.0 + IL_00dc: ldc.i4.1 + IL_00dd: conv.i8 + IL_00de: sub + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00f5: stloc.0 + IL_00f6: ldloc.0 + IL_00f7: ldc.i4.1 + IL_00f8: conv.i8 + IL_00f9: sub + IL_00fa: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0110: stloc.0 + IL_0111: ldloc.0 + IL_0112: ldc.i4.1 + IL_0113: conv.i8 + IL_0114: sub + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: ldc.i4.1 + IL_012e: conv.i8 + IL_012f: sub + IL_0130: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0146: stloc.0 + IL_0147: ldloc.0 + IL_0148: ldc.i4.1 + IL_0149: conv.i8 + IL_014a: sub + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: stloc.0 + IL_0163: ldloc.0 + IL_0164: ldc.i4.1 + IL_0165: conv.i8 + IL_0166: sub + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: ldc.i4.1 + IL_017c: conv.i8 + IL_017d: sub + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: sub + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UlongPostDecTest - .method public hidebysig instance void - DoubleInstanceProperty() cil managed + .method public hidebysig static void UlongPreDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleInstanceProperty + // Code size 413 (0x19d) + .maxstack 3 + .locals init (uint64 V_0) + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0005: ldc.i4.1 + IL_0006: conv.i8 + IL_0007: sub + IL_0008: dup + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0018: ldc.i4.1 + IL_0019: conv.i8 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0021: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0026: ldarg.1 + IL_0027: dup + IL_0028: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002d: ldc.i4.1 + IL_002e: conv.i8 + IL_002f: sub + IL_0030: stloc.0 + IL_0031: ldloc.0 + IL_0032: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0037: ldloc.0 + IL_0038: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003d: ldarg.1 + IL_003e: dup + IL_003f: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0044: ldc.i4.1 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: stloc.0 + IL_0048: ldloc.0 + IL_0049: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_004e: ldloc.0 + IL_004f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0054: ldarga.s s + IL_0056: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_005b: dup + IL_005c: ldind.i8 + IL_005d: ldc.i4.1 + IL_005e: conv.i8 + IL_005f: sub + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: stind.i8 + IL_0063: ldloc.0 + IL_0064: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0069: ldarga.s s + IL_006b: dup + IL_006c: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0071: ldc.i4.1 + IL_0072: conv.i8 + IL_0073: sub + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_007b: ldloc.0 + IL_007c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_008c: ldc.i4.1 + IL_008d: conv.i8 + IL_008e: sub + IL_008f: stloc.0 + IL_0090: ldloc.0 + IL_0091: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldloc.0 + IL_0097: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a1: dup + IL_00a2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00a7: ldc.i4.1 + IL_00a8: conv.i8 + IL_00a9: sub + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00b1: ldloc.0 + IL_00b2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bc: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00c1: dup + IL_00c2: ldind.i8 + IL_00c3: ldc.i4.1 + IL_00c4: conv.i8 + IL_00c5: sub + IL_00c6: stloc.0 + IL_00c7: ldloc.0 + IL_00c8: stind.i8 + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: dup + IL_00d5: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00da: ldc.i4.1 + IL_00db: conv.i8 + IL_00dc: sub + IL_00dd: stloc.0 + IL_00de: ldloc.0 + IL_00df: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00e4: ldloc.0 + IL_00e5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ea: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ef: dup + IL_00f0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00f5: ldc.i4.1 + IL_00f6: conv.i8 + IL_00f7: sub + IL_00f8: stloc.0 + IL_00f9: ldloc.0 + IL_00fa: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ff: ldloc.0 + IL_0100: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_010a: dup + IL_010b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0110: ldc.i4.1 + IL_0111: conv.i8 + IL_0112: sub + IL_0113: stloc.0 + IL_0114: ldloc.0 + IL_0115: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_011a: ldloc.0 + IL_011b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0120: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0125: dup + IL_0126: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_012b: ldc.i4.1 + IL_012c: conv.i8 + IL_012d: sub + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0140: dup + IL_0141: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0146: ldc.i4.1 + IL_0147: conv.i8 + IL_0148: sub + IL_0149: stloc.0 + IL_014a: ldloc.0 + IL_014b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0150: ldloc.0 + IL_0151: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0156: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_015b: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0160: dup + IL_0161: ldind.i8 + IL_0162: ldc.i4.1 + IL_0163: conv.i8 + IL_0164: sub + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: stind.i8 + IL_0168: ldloc.0 + IL_0169: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0173: dup + IL_0174: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0179: ldc.i4.1 + IL_017a: conv.i8 + IL_017b: sub + IL_017c: stloc.0 + IL_017d: ldloc.0 + IL_017e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0183: ldloc.0 + IL_0184: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0189: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_018e: dup + IL_018f: ldind.i8 + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: sub + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: stind.i8 + IL_0196: ldloc.0 + IL_0197: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_019c: ret + } // end of method CompoundAssignmentTest::UlongPreDecTest - .method public hidebysig instance int32 - DoubleInstancePropertyAndReturn() cil managed + .method public hidebysig static void CustomClassAddTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 332 (0x14c) .maxstack 3 - .locals init (int32 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: dup - IL_000f: stloc.0 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0015: ldloc.0 - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassAddTest - .method public hidebysig instance int32 - PreIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassSubtractTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 332 (0x14c) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.u1 - IL_000f: stloc.0 - IL_0010: ldloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassSubtractTest - .method public hidebysig instance int32 - PostIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassMultiplyTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 332 (0x14c) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.u1 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassMultiplyTest - .method public hidebysig instance void - IncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassDivideTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 332 (0x14c) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: ldc.i4.1 - IL_000f: add - IL_0010: conv.u1 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ret - } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassDivideTest - .method public hidebysig instance void - DoubleInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassModulusTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: conv.u1 - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + // Code size 332 (0x14c) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassModulusTest - .method public hidebysig instance int32 - DoubleInstancePropertyByteAndReturn() cil managed + .method public hidebysig static void CustomClassLeftShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 332 (0x14c) .maxstack 3 - .locals init (uint8 V_0) - IL_0000: ldarg.0 - IL_0001: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0006: dup - IL_0007: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000c: ldc.i4.2 - IL_000d: mul - IL_000e: conv.u1 - IL_000f: dup - IL_0010: stloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0016: ldloc.0 - IL_0017: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldc.i4.5 + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldc.i4.5 + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldc.i4.5 + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldc.i4.5 + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldc.i4.5 + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldc.i4.5 + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldc.i4.5 + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldc.i4.5 + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldc.i4.5 + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldc.i4.5 + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldc.i4.5 + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldc.i4.5 + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldc.i4.5 + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldc.i4.5 + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldc.i4.5 + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldc.i4.5 + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldc.i4.5 + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassLeftShiftTest + + .method public hidebysig static void CustomClassRightShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 332 (0x14c) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldc.i4.5 + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldc.i4.5 + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldc.i4.5 + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldc.i4.5 + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldc.i4.5 + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldc.i4.5 + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldc.i4.5 + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldc.i4.5 + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldc.i4.5 + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldc.i4.5 + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldc.i4.5 + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldc.i4.5 + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldc.i4.5 + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldc.i4.5 + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldc.i4.5 + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldc.i4.5 + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldc.i4.5 + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassRightShiftTest + + .method public hidebysig static void CustomClassBitAndTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 332 (0x14c) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassBitAndTest - .method public hidebysig instance int32 - PreIncrementStaticField() cil managed + .method public hidebysig static void CustomClassBitOrTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: dup - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticField + // Code size 332 (0x14c) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassBitOrTest - .method public hidebysig instance int32 - PostIncrementStaticField() cil managed + .method public hidebysig static void CustomClassBitXorTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + // Code size 332 (0x14c) + .maxstack 3 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: ldnull + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0015: ldnull + IL_0016: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0027: ldnull + IL_0028: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0039: ldnull + IL_003a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0044: ldarga.s s + IL_0046: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004b: dup + IL_004c: ldind.ref + IL_004d: ldnull + IL_004e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0053: stind.ref + IL_0054: ldarga.s s + IL_0056: dup + IL_0057: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005c: ldnull + IL_005d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0062: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0067: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006c: dup + IL_006d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0072: ldnull + IL_0073: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0078: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_007d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0082: dup + IL_0083: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0088: ldnull + IL_0089: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0093: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0098: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_009d: dup + IL_009e: ldind.ref + IL_009f: ldnull + IL_00a0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a5: stind.ref + IL_00a6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00ab: dup + IL_00ac: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b1: ldnull + IL_00b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00b7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c1: dup + IL_00c2: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00c7: ldnull + IL_00c8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cd: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00dd: ldnull + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00ed: dup + IL_00ee: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00f3: ldnull + IL_00f4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0103: dup + IL_0104: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0109: ldnull + IL_010a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0114: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0119: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_011e: dup + IL_011f: ldind.ref + IL_0120: ldnull + IL_0121: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0126: stind.ref + IL_0127: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_012c: dup + IL_012d: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0132: ldnull + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0138: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_0142: dup + IL_0143: ldind.ref + IL_0144: ldnull + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stind.ref + IL_014b: ret + } // end of method CompoundAssignmentTest::CustomClassBitXorTest + + .method public hidebysig static void CustomClassPostIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 447 (0x1bf) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: dup + IL_001b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: stloc.0 + IL_004b: ldloc.0 + IL_004c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0063: dup + IL_0064: ldind.ref + IL_0065: stloc.0 + IL_0066: ldloc.0 + IL_0067: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006c: stind.ref + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: ldarga.s s + IL_0075: dup + IL_0076: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007b: stloc.0 + IL_007c: ldloc.0 + IL_007d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0082: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0092: dup + IL_0093: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0098: stloc.0 + IL_0099: ldloc.0 + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a4: ldloc.0 + IL_00a5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: ldloc.0 + IL_00c2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d1: dup + IL_00d2: ldind.ref + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00da: stind.ref + IL_00db: ldloc.0 + IL_00dc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e6: dup + IL_00e7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00ec: stloc.0 + IL_00ed: ldloc.0 + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0103: dup + IL_0104: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0109: stloc.0 + IL_010a: ldloc.0 + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0110: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0120: dup + IL_0121: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0126: stloc.0 + IL_0127: ldloc.0 + IL_0128: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013d: dup + IL_013e: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0143: stloc.0 + IL_0144: ldloc.0 + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_014f: ldloc.0 + IL_0150: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0160: stloc.0 + IL_0161: ldloc.0 + IL_0162: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0167: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_016c: ldloc.0 + IL_016d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0177: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_017c: dup + IL_017d: ldind.ref + IL_017e: stloc.0 + IL_017f: ldloc.0 + IL_0180: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0185: stind.ref + IL_0186: ldloc.0 + IL_0187: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0191: dup + IL_0192: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0197: stloc.0 + IL_0198: ldloc.0 + IL_0199: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01a3: ldloc.0 + IL_01a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01ae: dup + IL_01af: ldind.ref + IL_01b0: stloc.0 + IL_01b1: ldloc.0 + IL_01b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b7: stind.ref + IL_01b8: ldloc.0 + IL_01b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01be: ret + } // end of method CompoundAssignmentTest::CustomClassPostIncTest - .method public hidebysig instance void - IncrementStaticField() cil managed + .method public hidebysig static void CustomClassPreIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000c: ret - } // end of method CompoundAssignmentTest::IncrementStaticField + // Code size 447 (0x1bf) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000a: dup + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0036: stloc.0 + IL_0037: ldloc.0 + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0063: dup + IL_0064: ldind.ref + IL_0065: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: stloc.0 + IL_006b: ldloc.0 + IL_006c: stind.ref + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: ldarga.s s + IL_0075: dup + IL_0076: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0080: stloc.0 + IL_0081: ldloc.0 + IL_0082: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0092: dup + IL_0093: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0098: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009d: stloc.0 + IL_009e: ldloc.0 + IL_009f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a4: ldloc.0 + IL_00a5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00b5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ba: stloc.0 + IL_00bb: ldloc.0 + IL_00bc: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: ldloc.0 + IL_00c2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d1: dup + IL_00d2: ldind.ref + IL_00d3: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d8: stloc.0 + IL_00d9: ldloc.0 + IL_00da: stind.ref + IL_00db: ldloc.0 + IL_00dc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e6: dup + IL_00e7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00ec: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f1: stloc.0 + IL_00f2: ldloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0103: dup + IL_0104: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0109: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010e: stloc.0 + IL_010f: ldloc.0 + IL_0110: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0120: dup + IL_0121: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013d: dup + IL_013e: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0143: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0148: stloc.0 + IL_0149: ldloc.0 + IL_014a: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_014f: ldloc.0 + IL_0150: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0160: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_016c: ldloc.0 + IL_016d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0177: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_017c: dup + IL_017d: ldind.ref + IL_017e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: stind.ref + IL_0186: ldloc.0 + IL_0187: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0191: dup + IL_0192: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0197: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019c: stloc.0 + IL_019d: ldloc.0 + IL_019e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01a3: ldloc.0 + IL_01a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01ae: dup + IL_01af: ldind.ref + IL_01b0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b5: stloc.0 + IL_01b6: ldloc.0 + IL_01b7: stind.ref + IL_01b8: ldloc.0 + IL_01b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01be: ret + } // end of method CompoundAssignmentTest::CustomClassPreIncTest - .method public hidebysig instance void - DoubleStaticField() cil managed + .method public hidebysig static void CustomClassPostDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000c: ret - } // end of method CompoundAssignmentTest::DoubleStaticField + // Code size 447 (0x1bf) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: dup + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: dup + IL_001b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: stloc.0 + IL_004b: ldloc.0 + IL_004c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0063: dup + IL_0064: ldind.ref + IL_0065: stloc.0 + IL_0066: ldloc.0 + IL_0067: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006c: stind.ref + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: ldarga.s s + IL_0075: dup + IL_0076: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007b: stloc.0 + IL_007c: ldloc.0 + IL_007d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0082: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0092: dup + IL_0093: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0098: stloc.0 + IL_0099: ldloc.0 + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a4: ldloc.0 + IL_00a5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: ldloc.0 + IL_00c2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d1: dup + IL_00d2: ldind.ref + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00da: stind.ref + IL_00db: ldloc.0 + IL_00dc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e6: dup + IL_00e7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00ec: stloc.0 + IL_00ed: ldloc.0 + IL_00ee: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0103: dup + IL_0104: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0109: stloc.0 + IL_010a: ldloc.0 + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0110: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0120: dup + IL_0121: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0126: stloc.0 + IL_0127: ldloc.0 + IL_0128: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013d: dup + IL_013e: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0143: stloc.0 + IL_0144: ldloc.0 + IL_0145: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_014a: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_014f: ldloc.0 + IL_0150: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0160: stloc.0 + IL_0161: ldloc.0 + IL_0162: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0167: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_016c: ldloc.0 + IL_016d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0177: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_017c: dup + IL_017d: ldind.ref + IL_017e: stloc.0 + IL_017f: ldloc.0 + IL_0180: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0185: stind.ref + IL_0186: ldloc.0 + IL_0187: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0191: dup + IL_0192: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0197: stloc.0 + IL_0198: ldloc.0 + IL_0199: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01a3: ldloc.0 + IL_01a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01ae: dup + IL_01af: ldind.ref + IL_01b0: stloc.0 + IL_01b1: ldloc.0 + IL_01b2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b7: stind.ref + IL_01b8: ldloc.0 + IL_01b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01be: ret + } // end of method CompoundAssignmentTest::CustomClassPostDecTest - .method public hidebysig instance int32 - DoubleStaticFieldAndReturn() cil managed + .method public hidebysig static void CustomClassPreDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: dup - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + // Code size 447 (0x1bf) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000a: dup + IL_000b: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0031: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0036: stloc.0 + IL_0037: ldloc.0 + IL_0038: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0063: dup + IL_0064: ldind.ref + IL_0065: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: stloc.0 + IL_006b: ldloc.0 + IL_006c: stind.ref + IL_006d: ldloc.0 + IL_006e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0073: ldarga.s s + IL_0075: dup + IL_0076: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_007b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0080: stloc.0 + IL_0081: ldloc.0 + IL_0082: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0087: ldloc.0 + IL_0088: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008d: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0092: dup + IL_0093: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0098: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_009d: stloc.0 + IL_009e: ldloc.0 + IL_009f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a4: ldloc.0 + IL_00a5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00aa: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00af: dup + IL_00b0: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00b5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ba: stloc.0 + IL_00bb: ldloc.0 + IL_00bc: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: ldloc.0 + IL_00c2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c7: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00cc: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00d1: dup + IL_00d2: ldind.ref + IL_00d3: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d8: stloc.0 + IL_00d9: ldloc.0 + IL_00da: stind.ref + IL_00db: ldloc.0 + IL_00dc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00e1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e6: dup + IL_00e7: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00ec: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f1: stloc.0 + IL_00f2: ldloc.0 + IL_00f3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0103: dup + IL_0104: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0109: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_010e: stloc.0 + IL_010f: ldloc.0 + IL_0110: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0115: ldloc.0 + IL_0116: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0120: dup + IL_0121: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0126: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012b: stloc.0 + IL_012c: ldloc.0 + IL_012d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0132: ldloc.0 + IL_0133: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0138: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_013d: dup + IL_013e: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0143: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0148: stloc.0 + IL_0149: ldloc.0 + IL_014a: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_014f: ldloc.0 + IL_0150: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0155: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015a: dup + IL_015b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0160: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0165: stloc.0 + IL_0166: ldloc.0 + IL_0167: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_016c: ldloc.0 + IL_016d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0177: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_017c: dup + IL_017d: ldind.ref + IL_017e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: stind.ref + IL_0186: ldloc.0 + IL_0187: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_018c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0191: dup + IL_0192: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0197: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019c: stloc.0 + IL_019d: ldloc.0 + IL_019e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01a3: ldloc.0 + IL_01a4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01ae: dup + IL_01af: ldind.ref + IL_01b0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b5: stloc.0 + IL_01b6: ldloc.0 + IL_01b7: stind.ref + IL_01b8: ldloc.0 + IL_01b9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01be: ret + } // end of method CompoundAssignmentTest::CustomClassPreDecTest - .method public hidebysig instance int32 - PreIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructAddTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: dup - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructAddTest - .method public hidebysig instance int32 - PostIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructSubtractTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructSubtractTest - .method public hidebysig instance void - IncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructMultiplyTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructMultiplyTest - .method public hidebysig instance void - DoubleStaticFieldShort() cil managed + .method public hidebysig static void CustomStructDivideTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: conv.i2 - IL_0008: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructDivideTest - .method public hidebysig instance int16 - DoubleStaticFieldAndReturnShort() cil managed + .method public hidebysig static void CustomStructModulusTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: conv.i2 - IL_0008: dup - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructModulusTest - .method public hidebysig instance int32 - PreIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructLeftShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: dup - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + // Code size 364 (0x16c) + .maxstack 3 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldc.i4.5 + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0015: ldc.i4.5 + IL_0016: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0027: ldc.i4.5 + IL_0028: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0039: ldc.i4.5 + IL_003a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0044: ldarga.s s + IL_0046: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004b: dup + IL_004c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0051: ldc.i4.5 + IL_0052: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0057: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0064: ldc.i4.5 + IL_0065: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_006a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_007a: ldc.i4.5 + IL_007b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0080: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0090: ldc.i4.5 + IL_0091: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0096: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a5: dup + IL_00a6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ab: ldc.i4.5 + IL_00ac: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00b1: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00c1: ldc.i4.5 + IL_00c2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00c7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d1: dup + IL_00d2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d7: ldc.i4.5 + IL_00d8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00dd: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e7: dup + IL_00e8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ed: ldc.i4.5 + IL_00ee: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00f3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fd: dup + IL_00fe: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0103: ldc.i4.5 + IL_0104: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0109: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0113: dup + IL_0114: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0119: ldc.i4.5 + IL_011a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_011f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0124: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0129: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_012e: dup + IL_012f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0134: ldc.i4.5 + IL_0135: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_013a: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_013f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0144: dup + IL_0145: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_014a: ldc.i4.5 + IL_014b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0150: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_015a: dup + IL_015b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0160: ldc.i4.5 + IL_0161: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0166: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ret + } // end of method CompoundAssignmentTest::CustomStructLeftShiftTest - .method public hidebysig instance int32 - PostIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructRightShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + // Code size 364 (0x16c) + .maxstack 3 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldc.i4.5 + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0015: ldc.i4.5 + IL_0016: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: ldarg.1 + IL_0021: dup + IL_0022: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0027: ldc.i4.5 + IL_0028: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0039: ldc.i4.5 + IL_003a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_003f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0044: ldarga.s s + IL_0046: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004b: dup + IL_004c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0051: ldc.i4.5 + IL_0052: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0057: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005c: ldarga.s s + IL_005e: dup + IL_005f: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0064: ldc.i4.5 + IL_0065: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_006a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0074: dup + IL_0075: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_007a: ldc.i4.5 + IL_007b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0080: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0090: ldc.i4.5 + IL_0091: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0096: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009b: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00a5: dup + IL_00a6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ab: ldc.i4.5 + IL_00ac: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00b1: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00bb: dup + IL_00bc: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00c1: ldc.i4.5 + IL_00c2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00c7: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d1: dup + IL_00d2: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00d7: ldc.i4.5 + IL_00d8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00dd: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00e7: dup + IL_00e8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00ed: ldc.i4.5 + IL_00ee: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00f3: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00fd: dup + IL_00fe: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0103: ldc.i4.5 + IL_0104: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0109: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0113: dup + IL_0114: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0119: ldc.i4.5 + IL_011a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_011f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0124: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0129: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_012e: dup + IL_012f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0134: ldc.i4.5 + IL_0135: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_013a: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_013f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0144: dup + IL_0145: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_014a: ldc.i4.5 + IL_014b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0150: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_015a: dup + IL_015b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0160: ldc.i4.5 + IL_0161: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0166: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ret + } // end of method CompoundAssignmentTest::CustomStructRightShiftTest - .method public hidebysig instance void - IncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructBitAndTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000c: ret - } // end of method CompoundAssignmentTest::IncrementStaticProperty + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructBitAndTest - .method public hidebysig instance void - DoubleStaticProperty() cil managed + .method public hidebysig static void CustomStructBitOrTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 13 (0xd) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000c: ret - } // end of method CompoundAssignmentTest::DoubleStaticProperty + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructBitOrTest - .method public hidebysig instance int32 - DoubleStaticPropertyAndReturn() cil managed + .method public hidebysig static void CustomStructBitXorTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 - IL_0000: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0005: ldc.i4.2 - IL_0006: mul - IL_0007: dup - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + // Code size 500 (0x1f4) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: ldloca.s V_0 + IL_0007: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000d: ldloc.0 + IL_000e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0013: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0018: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001d: ldloca.s V_0 + IL_001f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0025: ldloc.0 + IL_0026: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0030: ldarg.1 + IL_0031: dup + IL_0032: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0037: ldloca.s V_0 + IL_0039: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_003f: ldloc.0 + IL_0040: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0045: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004a: ldarg.1 + IL_004b: dup + IL_004c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0051: ldloca.s V_0 + IL_0053: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0059: ldloc.0 + IL_005a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0064: ldarga.s s + IL_0066: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006b: dup + IL_006c: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0071: ldloca.s V_0 + IL_0073: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0079: ldloc.0 + IL_007a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_007f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0084: ldarga.s s + IL_0086: dup + IL_0087: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008c: ldloca.s V_0 + IL_008e: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0094: ldloc.0 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: ldloca.s V_0 + IL_00ac: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b2: ldloc.0 + IL_00b3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b8: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: ldloca.s V_0 + IL_00ca: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d0: ldloc.0 + IL_00d1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d6: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00db: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e0: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e5: dup + IL_00e6: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloca.s V_0 + IL_00ed: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f3: ldloc.0 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f9: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00fe: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0103: dup + IL_0104: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0109: ldloca.s V_0 + IL_010b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0111: ldloc.0 + IL_0112: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0117: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0121: dup + IL_0122: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0127: ldloca.s V_0 + IL_0129: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_012f: ldloc.0 + IL_0130: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0135: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_013a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_013f: dup + IL_0140: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0145: ldloca.s V_0 + IL_0147: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_014d: ldloc.0 + IL_014e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_015d: dup + IL_015e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0163: ldloca.s V_0 + IL_0165: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_016b: ldloc.0 + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0171: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017b: dup + IL_017c: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0181: ldloca.s V_0 + IL_0183: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0189: ldloc.0 + IL_018a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0199: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_019e: dup + IL_019f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a4: ldloca.s V_0 + IL_01a6: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloc.0 + IL_01ad: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b2: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01bc: dup + IL_01bd: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c2: ldloca.s V_0 + IL_01c4: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ca: ldloc.0 + IL_01cb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d0: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01da: dup + IL_01db: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e0: ldloca.s V_0 + IL_01e2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e8: ldloc.0 + IL_01e9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ee: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f3: ret + } // end of method CompoundAssignmentTest::CustomStructBitXorTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PreIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPostIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + // Code size 479 (0x1df) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: dup + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: dup + IL_001b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: stloc.0 + IL_004b: ldloc.0 + IL_004c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0063: dup + IL_0064: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0069: stloc.0 + IL_006a: ldloc.0 + IL_006b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0070: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0083: stloc.0 + IL_0084: ldloc.0 + IL_0085: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ac: ldloc.0 + IL_00ad: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b2: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b7: dup + IL_00b8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloc.0 + IL_00ec: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f6: dup + IL_00f7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00fc: stloc.0 + IL_00fd: ldloc.0 + IL_00fe: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0103: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0108: ldloc.0 + IL_0109: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0119: stloc.0 + IL_011a: ldloc.0 + IL_011b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0120: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: stloc.0 + IL_0137: ldloc.0 + IL_0138: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0153: stloc.0 + IL_0154: ldloc.0 + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015f: ldloc.0 + IL_0160: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0165: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016a: dup + IL_016b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0170: stloc.0 + IL_0171: ldloc.0 + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0177: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: ldloc.0 + IL_017d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0182: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0187: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_018c: dup + IL_018d: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0192: stloc.0 + IL_0193: ldloc.0 + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0199: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a9: dup + IL_01aa: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01af: stloc.0 + IL_01b0: ldloc.0 + IL_01b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b6: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01c6: dup + IL_01c7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01cc: stloc.0 + IL_01cd: ldloc.0 + IL_01ce: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d8: ldloc.0 + IL_01d9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01de: ret + } // end of method CompoundAssignmentTest::CustomStructPostIncTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PostIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPreIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + // Code size 479 (0x1df) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000a: dup + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0036: stloc.0 + IL_0037: ldloc.0 + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0063: dup + IL_0064: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0069: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0083: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a5: stloc.0 + IL_00a6: ldloc.0 + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ac: ldloc.0 + IL_00ad: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b2: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b7: dup + IL_00b8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: stloc.0 + IL_00c3: ldloc.0 + IL_00c4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00df: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e4: stloc.0 + IL_00e5: ldloc.0 + IL_00e6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloc.0 + IL_00ec: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f6: dup + IL_00f7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00fc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0101: stloc.0 + IL_0102: ldloc.0 + IL_0103: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0108: ldloc.0 + IL_0109: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0119: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011e: stloc.0 + IL_011f: ldloc.0 + IL_0120: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0153: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: stloc.0 + IL_0159: ldloc.0 + IL_015a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015f: ldloc.0 + IL_0160: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0165: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016a: dup + IL_016b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0170: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0175: stloc.0 + IL_0176: ldloc.0 + IL_0177: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: ldloc.0 + IL_017d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0182: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0187: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_018c: dup + IL_018d: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0192: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0197: stloc.0 + IL_0198: ldloc.0 + IL_0199: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a9: dup + IL_01aa: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01af: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b4: stloc.0 + IL_01b5: ldloc.0 + IL_01b6: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01c6: dup + IL_01c7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01cc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d1: stloc.0 + IL_01d2: ldloc.0 + IL_01d3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d8: ldloc.0 + IL_01d9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01de: ret + } // end of method CompoundAssignmentTest::CustomStructPreIncTest + + .method public hidebysig static void CustomStructPostDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 479 (0x1df) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField IL_0005: dup - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: dup + IL_001b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: stloc.0 + IL_004b: ldloc.0 + IL_004c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0063: dup + IL_0064: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0069: stloc.0 + IL_006a: ldloc.0 + IL_006b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0070: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0083: stloc.0 + IL_0084: ldloc.0 + IL_0085: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a0: stloc.0 + IL_00a1: ldloc.0 + IL_00a2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ac: ldloc.0 + IL_00ad: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b2: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b7: dup + IL_00b8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00bd: stloc.0 + IL_00be: ldloc.0 + IL_00bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloc.0 + IL_00ec: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f6: dup + IL_00f7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00fc: stloc.0 + IL_00fd: ldloc.0 + IL_00fe: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0103: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0108: ldloc.0 + IL_0109: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0119: stloc.0 + IL_011a: ldloc.0 + IL_011b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0120: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: stloc.0 + IL_0137: ldloc.0 + IL_0138: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0153: stloc.0 + IL_0154: ldloc.0 + IL_0155: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015f: ldloc.0 + IL_0160: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0165: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016a: dup + IL_016b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0170: stloc.0 + IL_0171: ldloc.0 + IL_0172: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0177: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: ldloc.0 + IL_017d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0182: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0187: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_018c: dup + IL_018d: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0192: stloc.0 + IL_0193: ldloc.0 + IL_0194: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0199: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a9: dup + IL_01aa: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01af: stloc.0 + IL_01b0: ldloc.0 + IL_01b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b6: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01c6: dup + IL_01c7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01cc: stloc.0 + IL_01cd: ldloc.0 + IL_01ce: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d8: ldloc.0 + IL_01d9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01de: ret + } // end of method CompoundAssignmentTest::CustomStructPostDecTest - .method public hidebysig instance void - IncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPreDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) + // Code size 479 (0x1df) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0005: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000a: dup + IL_000b: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0010: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0015: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_001f: dup + IL_0020: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0025: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0031: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0036: stloc.0 + IL_0037: ldloc.0 + IL_0038: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_003d: ldloc.0 + IL_003e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0043: ldarg.1 + IL_0044: dup + IL_0045: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: ldloc.0 + IL_0057: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005c: ldarga.s s + IL_005e: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0063: dup + IL_0064: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0069: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_006e: stloc.0 + IL_006f: ldloc.0 + IL_0070: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0075: ldloc.0 + IL_0076: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0083: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_008f: ldloc.0 + IL_0090: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0095: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009a: dup + IL_009b: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00a0: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a5: stloc.0 + IL_00a6: ldloc.0 + IL_00a7: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ac: ldloc.0 + IL_00ad: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b2: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00b7: dup + IL_00b8: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00bd: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c2: stloc.0 + IL_00c3: ldloc.0 + IL_00c4: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00c9: ldloc.0 + IL_00ca: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00cf: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d4: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00d9: dup + IL_00da: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00df: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00e4: stloc.0 + IL_00e5: ldloc.0 + IL_00e6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00eb: ldloc.0 + IL_00ec: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f1: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f6: dup + IL_00f7: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00fc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0101: stloc.0 + IL_0102: ldloc.0 + IL_0103: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0108: ldloc.0 + IL_0109: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0119: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011e: stloc.0 + IL_011f: ldloc.0 + IL_0120: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0130: dup + IL_0131: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stloc.0 + IL_013c: ldloc.0 + IL_013d: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0142: ldloc.0 + IL_0143: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0148: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_014d: dup + IL_014e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0153: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0158: stloc.0 + IL_0159: ldloc.0 + IL_015a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_015f: ldloc.0 + IL_0160: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0165: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016a: dup + IL_016b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0170: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0175: stloc.0 + IL_0176: ldloc.0 + IL_0177: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_017c: ldloc.0 + IL_017d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0182: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0187: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_018c: dup + IL_018d: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0192: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0197: stloc.0 + IL_0198: ldloc.0 + IL_0199: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a9: dup + IL_01aa: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01af: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01b4: stloc.0 + IL_01b5: ldloc.0 + IL_01b6: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01c6: dup + IL_01c7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01cc: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d1: stloc.0 + IL_01d2: ldloc.0 + IL_01d3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d8: ldloc.0 + IL_01d9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01de: ret + } // end of method CompoundAssignmentTest::CustomStructPreDecTest + + .method public hidebysig static void AddOneToCustomClass(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& c) cil managed + { + // Code size 30 (0x1e) .maxstack 8 - IL_0000: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0005: ldc.i4.1 - IL_0006: add - IL_0007: conv.i2 - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + IL_0000: ldarg.0 + IL_0001: ldarg.0 + IL_0002: ldind.ref + IL_0003: ldc.i4.1 + IL_0004: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0009: stind.ref + IL_000a: ldarg.0 + IL_000b: ldind.ref + IL_000c: dup + IL_000d: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0012: ldc.i4.1 + IL_0013: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0018: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001d: ret + } // end of method CompoundAssignmentTest::AddOneToCustomClass .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/Item GetItem(object obj) cil managed @@ -1616,25 +23044,20 @@ .method private hidebysig instance void Issue588(uint16 val) cil managed { - // Code size 31 (0x1f) - .maxstack 4 - .locals init (uint16 V_0) + // Code size 27 (0x1b) + .maxstack 8 IL_0000: ldarg.0 IL_0001: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortDict - IL_0006: ldarg.0 - IL_0007: ldarg.0 - IL_0008: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.u2 - IL_0012: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_0017: ldloc.0 - IL_0018: ldarg.1 - IL_0019: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, + IL_0006: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000b: dup + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.u2 + IL_000f: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0014: ldarg.1 + IL_0015: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) - IL_001e: ret + IL_001a: ret } // end of method CompoundAssignmentTest::Issue588 .method private hidebysig instance void @@ -1679,6 +23102,58 @@ IL_0011: ret } // end of method CompoundAssignmentTest::.ctor + .property class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CompoundAssignmentTest::CustomClassProp + .property valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CompoundAssignmentTest::CustomStructProp + .property uint8 ByteProp() + { + .get uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + } // end of property CompoundAssignmentTest::ByteProp + .property int8 SbyteProp() + { + .get int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + } // end of property CompoundAssignmentTest::SbyteProp + .property int16 ShortProp() + { + .get int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + } // end of property CompoundAssignmentTest::ShortProp + .property uint16 UshortProp() + { + .get uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + } // end of property CompoundAssignmentTest::UshortProp + .property int32 IntProp() + { + .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + } // end of property CompoundAssignmentTest::IntProp + .property uint32 UintProp() + { + .get uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + } // end of property CompoundAssignmentTest::UintProp + .property int64 LongProp() + { + .get int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + } // end of property CompoundAssignmentTest::LongProp + .property uint64 UlongProp() + { + .get uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + } // end of property CompoundAssignmentTest::UlongProp .property int32 StaticProperty() { .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.roslyn.il index 1fc6e0675..b3e492a42 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/CompoundAssignmentTest.roslyn.il @@ -193,1708 +193,25156 @@ } // end of class Item + .class auto ansi nested public beforefieldinit CustomClass + extends [mscorlib]System.Object + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_UlongProp + + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0006: ret + } // end of method CustomClass::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::'k__BackingField' + IL_0007: ret + } // end of method CustomClass::set_CustomStructProp + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Addition + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Subtraction + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Multiply + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Division + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Modulus + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_LeftShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_RightShift + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_BitwiseAnd + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_BitwiseOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_ExclusiveOr + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Increment + + .method public hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomClass::op_Decrement + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: nop + IL_0007: ret + } // end of method CustomClass::.ctor + + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + } // end of property CustomClass::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + } // end of property CustomClass::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + } // end of property CustomClass::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + } // end of property CustomClass::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + } // end of property CustomClass::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + } // end of property CustomClass::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + } // end of property CustomClass::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + } // end of property CustomClass::UlongProp + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomClass::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomClass::CustomStructProp + } // end of class CustomClass + + .class sequential ansi sealed nested public beforefieldinit CustomStruct + extends [mscorlib]System.ValueType + { + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_CustomClassProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct::set_UlongProp + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Addition + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Subtraction + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Multiply + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Division + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Modulus + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_LeftShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + int32 rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_RightShift + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_BitwiseAnd + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_BitwiseOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct rhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_ExclusiveOr + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Increment + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct lhs) cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CustomStruct::op_Decrement + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct::CustomClassProp + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ByteProp(uint8) + } // end of property CustomStruct::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_SbyteProp(int8) + } // end of property CustomStruct::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_ShortProp(int16) + } // end of property CustomStruct::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UshortProp(uint16) + } // end of property CustomStruct::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_IntProp(int32) + } // end of property CustomStruct::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UintProp(uint32) + } // end of property CustomStruct::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_LongProp(int64) + } // end of property CustomStruct::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::set_UlongProp(uint64) + } // end of property CustomStruct::UlongProp + } // end of class CustomStruct + + .class sequential ansi sealed nested public beforefieldinit CustomStruct2 + extends [mscorlib]System.ValueType + { + .field public class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass CustomClassField + .field public valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct CustomStructField + .field public uint8 ByteField + .field public int8 SbyteField + .field public int16 ShortField + .field public uint16 UshortField + .field public int32 IntField + .field public uint32 UintField + .field public int64 LongField + .field public uint64 UlongField + .field private class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .method public hidebysig specialname + instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomClassProp + + .method public hidebysig specialname + instance void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomClassProp + + .method public hidebysig specialname + instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_CustomStructProp + + .method public hidebysig specialname + instance void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_CustomStructProp + + .method public hidebysig specialname + instance uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ByteProp + + .method public hidebysig specialname + instance void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ByteProp + + .method public hidebysig specialname + instance int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_SbyteProp + + .method public hidebysig specialname + instance void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_SbyteProp + + .method public hidebysig specialname + instance int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_ShortProp + + .method public hidebysig specialname + instance void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_ShortProp + + .method public hidebysig specialname + instance uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UshortProp + + .method public hidebysig specialname + instance void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UshortProp + + .method public hidebysig specialname + instance int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_IntProp + + .method public hidebysig specialname + instance void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_IntProp + + .method public hidebysig specialname + instance uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UintProp + + .method public hidebysig specialname + instance void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UintProp + + .method public hidebysig specialname + instance int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_LongProp + + .method public hidebysig specialname + instance void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_LongProp + + .method public hidebysig specialname + instance uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0006: ret + } // end of method CustomStruct2::get_UlongProp + + .method public hidebysig specialname + instance void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::'k__BackingField' + IL_0007: ret + } // end of method CustomStruct2::set_UlongProp + + .property instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CustomStruct2::CustomClassProp + .property instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CustomStruct2::CustomStructProp + .property instance uint8 ByteProp() + { + .get instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + } // end of property CustomStruct2::ByteProp + .property instance int8 SbyteProp() + { + .get instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + } // end of property CustomStruct2::SbyteProp + .property instance int16 ShortProp() + { + .get instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + } // end of property CustomStruct2::ShortProp + .property instance uint16 UshortProp() + { + .get instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + } // end of property CustomStruct2::UshortProp + .property instance int32 IntProp() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + } // end of property CustomStruct2::IntProp + .property instance uint32 UintProp() + { + .get instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + } // end of property CustomStruct2::UintProp + .property instance int64 LongProp() + { + .get instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + } // end of property CustomStruct2::LongProp + .property instance uint64 UlongProp() + { + .get instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + } // end of property CustomStruct2::UlongProp + } // end of class CustomStruct2 + .field private int32 test1 .field private int32[] array1 .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer field1 .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum enumField .field private class [mscorlib]System.Collections.Generic.Dictionary`2 ushortDict - .field private uint16 ushortField .field private valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum shortEnumField .field public static int32 StaticField .field public static int16 StaticShortField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass customClassField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct customStructField + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 otherCustomStructField + .field private static uint8 byteField + .field private static int8 sbyteField + .field private static int16 shortField + .field private static uint16 ushortField + .field private static int32 intField + .field private static uint32 uintField + .field private static int64 longField + .field private static uint64 ulongField + .field private static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static uint8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static int8 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static int16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static uint16 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static int32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static uint32 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static int64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .field private static uint64 'k__BackingField' + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) .field private static int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) .field private static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) + .method private hidebysig specialname static + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + get_CustomClassProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomClassProp + + .method private hidebysig specialname static + void set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomClassProp + + .method private hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + get_CustomStructProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_CustomStructProp + + .method private hidebysig specialname static + void set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_CustomStructProp + + .method private hidebysig specialname static + uint8 get_ByteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ByteProp + + .method private hidebysig specialname static + void set_ByteProp(uint8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ByteProp + + .method private hidebysig specialname static + int8 get_SbyteProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_SbyteProp + + .method private hidebysig specialname static + void set_SbyteProp(int8 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_SbyteProp + + .method private hidebysig specialname static + int16 get_ShortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_ShortProp + + .method private hidebysig specialname static + void set_ShortProp(int16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_ShortProp + + .method private hidebysig specialname static + uint16 get_UshortProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UshortProp + + .method private hidebysig specialname static + void set_UshortProp(uint16 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UshortProp + + .method private hidebysig specialname static + int32 get_IntProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_IntProp + + .method private hidebysig specialname static + void set_IntProp(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_IntProp + + .method private hidebysig specialname static + uint32 get_UintProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UintProp + + .method private hidebysig specialname static + void set_UintProp(uint32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UintProp + + .method private hidebysig specialname static + int64 get_LongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_LongProp + + .method private hidebysig specialname static + void set_LongProp(int64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_LongProp + + .method private hidebysig specialname static + uint64 get_UlongProp() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_UlongProp + + .method private hidebysig specialname static + void set_UlongProp(uint64 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_UlongProp + .method public hidebysig specialname static int32 get_StaticProperty() cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticProperty + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticProperty + + .method public hidebysig specialname static + void set_StaticProperty(int32 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticProperty + + .method public hidebysig specialname static + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + get_StaticShortProperty() cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 6 (0x6) + .maxstack 8 + IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0005: ret + } // end of method CompoundAssignmentTest::get_StaticShortProperty + + .method public hidebysig specialname static + void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' + IL_0006: ret + } // end of method CompoundAssignmentTest::set_StaticShortProperty + + .method private hidebysig static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& + GetStruct() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetStruct + + .method private hidebysig static valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& + GetRefCustomStruct() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefCustomStruct + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& + GetRefCustomClass() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefCustomClass + + .method private hidebysig static uint8& + GetRefByte() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefByte + + .method private hidebysig static int8& + GetRefSbyte() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefSbyte + + .method private hidebysig static int16& + GetRefShort() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefShort + + .method private hidebysig static int32& + GetRefInt() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefInt + + .method private hidebysig static int64& + GetRefLong() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefLong + + .method private hidebysig static uint16& + GetRefUshort() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefUshort + + .method private hidebysig static uint32& + GetRefUint() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefUint + + .method private hidebysig static uint64& + GetRefUlong() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetRefUlong + + .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + GetClass() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetClass + + .method private hidebysig static void X(!!T result) cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: nop + IL_0001: ret + } // end of method CompoundAssignmentTest::X + + .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass + M() cil managed + { + // Code size 11 (0xb) + .maxstack 1 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass V_0) + IL_0000: nop + IL_0001: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CompoundAssignmentTest::M + + .method private hidebysig instance int32[0...,0...] + Array() cil managed + { + // Code size 7 (0x7) + .maxstack 1 + .locals init (int32[0...,0...] V_0) + IL_0000: nop + IL_0001: ldnull + IL_0002: stloc.0 + IL_0003: br.s IL_0005 + + IL_0005: ldloc.0 + IL_0006: ret + } // end of method CompoundAssignmentTest::Array + + .method private hidebysig instance int32* + GetPointer() cil managed + { + // Code size 8 (0x8) + .maxstack 1 + .locals init (int32* V_0) + IL_0000: nop + IL_0001: ldc.i4.0 + IL_0002: conv.u + IL_0003: stloc.0 + IL_0004: br.s IL_0006 + + IL_0006: ldloc.0 + IL_0007: ret + } // end of method CompoundAssignmentTest::GetPointer + + .method public hidebysig instance int32 + GetIndex() cil managed + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.Random::.ctor() + IL_0006: ldc.i4.0 + IL_0007: ldc.i4.s 100 + IL_0009: callvirt instance int32 [mscorlib]System.Random::Next(int32, + int32) + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::GetIndex + + .method public hidebysig instance int32[] + GetArray() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: nop + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method CompoundAssignmentTest::GetArray + + .method public hidebysig instance int32 + GetValue(int32 'value') cil managed + { + // Code size 7 (0x7) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: stloc.0 + IL_0003: br.s IL_0005 + + IL_0005: ldloc.0 + IL_0006: ret + } // end of method CompoundAssignmentTest::GetValue + + .method public hidebysig instance bool + IsUpperCaseA(char a) cil managed + { + // Code size 11 (0xb) + .maxstack 2 + .locals init (bool V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.s 65 + IL_0004: ceq + IL_0006: stloc.0 + IL_0007: br.s IL_0009 + + IL_0009: ldloc.0 + IL_000a: ret + } // end of method CompoundAssignmentTest::IsUpperCaseA + + .method public hidebysig instance void + Int32_Local_Add(int32 i) cil managed + { + // Code size 48 (0x30) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.1 + IL_0003: add + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: dup + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ldarg.1 + IL_0013: ldc.i4.1 + IL_0014: add + IL_0015: dup + IL_0016: starg.s i + IL_0018: call void [mscorlib]System.Console::WriteLine(int32) + IL_001d: nop + IL_001e: ldarg.1 + IL_001f: ldc.i4.5 + IL_0020: add + IL_0021: starg.s i + IL_0023: ldarg.1 + IL_0024: ldc.i4.5 + IL_0025: add + IL_0026: dup + IL_0027: starg.s i + IL_0029: call void [mscorlib]System.Console::WriteLine(int32) + IL_002e: nop + IL_002f: ret + } // end of method CompoundAssignmentTest::Int32_Local_Add + + .method public hidebysig instance void + Int32_Local_Sub(int32 i) cil managed + { + // Code size 48 (0x30) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.1 + IL_0003: sub + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: dup + IL_0008: ldc.i4.1 + IL_0009: sub + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ldarg.1 + IL_0013: ldc.i4.1 + IL_0014: sub + IL_0015: dup + IL_0016: starg.s i + IL_0018: call void [mscorlib]System.Console::WriteLine(int32) + IL_001d: nop + IL_001e: ldarg.1 + IL_001f: ldc.i4.5 + IL_0020: sub + IL_0021: starg.s i + IL_0023: ldarg.1 + IL_0024: ldc.i4.5 + IL_0025: sub + IL_0026: dup + IL_0027: starg.s i + IL_0029: call void [mscorlib]System.Console::WriteLine(int32) + IL_002e: nop + IL_002f: ret + } // end of method CompoundAssignmentTest::Int32_Local_Sub + + .method public hidebysig instance void + Int32_Local_Mul(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: mul + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: mul + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Mul + + .method public hidebysig instance void + Int32_Local_Div(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: div + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: div + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Div + + .method public hidebysig instance void + Int32_Local_Rem(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: rem + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: rem + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_Rem + + .method public hidebysig instance void + Int32_Local_BitAnd(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: and + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: and + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + + .method public hidebysig instance void + Int32_Local_BitOr(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: or + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: or + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitOr + + .method public hidebysig instance void + Int32_Local_BitXor(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: xor + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: xor + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_BitXor + + .method public hidebysig instance void + Int32_Local_ShiftLeft(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: shl + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: shl + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + + .method public hidebysig instance void + Int32_Local_ShiftRight(int32 i) cil managed + { + // Code size 19 (0x13) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: shr + IL_0004: starg.s i + IL_0006: ldarg.1 + IL_0007: ldc.i4.5 + IL_0008: shr + IL_0009: dup + IL_000a: starg.s i + IL_000c: call void [mscorlib]System.Console::WriteLine(int32) + IL_0011: nop + IL_0012: ret + } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + + .method public hidebysig instance void + IntegerWithInline(int32 i) cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldc.i4.5 + IL_0003: add + IL_0004: dup + IL_0005: starg.s i + IL_0007: call void [mscorlib]System.Console::WriteLine(int32) + IL_000c: nop + IL_000d: ldarg.1 + IL_000e: call void [mscorlib]System.Console::WriteLine(int32) + IL_0013: nop + IL_0014: ret + } // end of method CompoundAssignmentTest::IntegerWithInline + + .method public hidebysig instance void + IntegerField(int32 i) cil managed + { + // Code size 72 (0x48) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldarg.0 + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0008: ldarg.1 + IL_0009: add + IL_000a: dup + IL_000b: stloc.0 + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0011: ldloc.0 + IL_0012: call void [mscorlib]System.Console::WriteLine(int32) + IL_0017: nop + IL_0018: ldarg.0 + IL_0019: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_001e: call void [mscorlib]System.Console::WriteLine(int32) + IL_0023: nop + IL_0024: ldarg.0 + IL_0025: ldarg.0 + IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_002b: ldarg.1 + IL_002c: sub + IL_002d: dup + IL_002e: stloc.0 + IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0034: ldloc.0 + IL_0035: call void [mscorlib]System.Console::WriteLine(int32) + IL_003a: nop + IL_003b: ldarg.0 + IL_003c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 + IL_0041: call void [mscorlib]System.Console::WriteLine(int32) + IL_0046: nop + IL_0047: ret + } // end of method CompoundAssignmentTest::IntegerField + + .method public hidebysig instance void + Array(int32 i) cil managed + { + // Code size 58 (0x3a) + .maxstack 4 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0007: ldarg.1 + IL_0008: ldelema [mscorlib]System.Int32 + IL_000d: dup + IL_000e: ldind.i4 + IL_000f: ldarg.1 + IL_0010: add + IL_0011: dup + IL_0012: stloc.0 + IL_0013: stind.i4 + IL_0014: ldloc.0 + IL_0015: call void [mscorlib]System.Console::WriteLine(int32) + IL_001a: nop + IL_001b: ldarg.0 + IL_001c: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 + IL_0021: ldarg.1 + IL_0022: ldc.i4.2 + IL_0023: mul + IL_0024: ldelema [mscorlib]System.Int32 + IL_0029: dup + IL_002a: ldind.i4 + IL_002b: ldarg.1 + IL_002c: ldc.i4.2 + IL_002d: mul + IL_002e: add + IL_002f: dup + IL_0030: stloc.0 + IL_0031: stind.i4 + IL_0032: ldloc.0 + IL_0033: call void [mscorlib]System.Console::WriteLine(int32) + IL_0038: nop + IL_0039: ret + } // end of method CompoundAssignmentTest::Array + + .method public hidebysig instance int32 + ArrayUsageWithMethods() cil managed + { + // Code size 31 (0x1f) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() + IL_0007: ldarg.0 + IL_0008: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() + IL_000d: ldelema [mscorlib]System.Int32 + IL_0012: dup + IL_0013: ldind.i4 + IL_0014: stloc.0 + IL_0015: ldloc.0 + IL_0016: ldc.i4.1 + IL_0017: add + IL_0018: stind.i4 + IL_0019: ldloc.0 + IL_001a: stloc.1 + IL_001b: br.s IL_001d + + IL_001d: ldloc.1 + IL_001e: ret + } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + + .method public hidebysig instance void + NestedField() cil managed + { + // Code size 85 (0x55) + .maxstack 3 + .locals init (bool V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0007: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: brfalse.s IL_0054 + + IL_0010: nop + IL_0011: ldarg.0 + IL_0012: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0017: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_001c: dup + IL_001d: ldind.i4 + IL_001e: ldc.i4.2 + IL_001f: mul + IL_0020: dup + IL_0021: stloc.1 + IL_0022: stind.i4 + IL_0023: ldloc.1 + IL_0024: call void [mscorlib]System.Console::WriteLine(int32) + IL_0029: nop + IL_002a: ldarg.0 + IL_002b: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0030: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0035: dup + IL_0036: ldind.i4 + IL_0037: ldc.i4.1 + IL_0038: add + IL_0039: stind.i4 + IL_003a: ldarg.0 + IL_003b: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 + IL_0040: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0045: dup + IL_0046: ldind.i4 + IL_0047: stloc.1 + IL_0048: ldloc.1 + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: stind.i4 + IL_004c: ldloc.1 + IL_004d: call void [mscorlib]System.Console::WriteLine(int32) + IL_0052: nop + IL_0053: nop + IL_0054: ret + } // end of method CompoundAssignmentTest::NestedField + + .method public hidebysig instance void + Enum() cil managed + { + // Code size 59 (0x3b) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldarg.0 + IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0008: ldc.i4.2 + IL_0009: or + IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_000f: ldarg.0 + IL_0010: ldarg.0 + IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0016: ldc.i4.s -5 + IL_0018: and + IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_001e: ldarg.0 + IL_001f: ldarg.0 + IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0025: ldc.i4.2 + IL_0026: add + IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_002c: ldarg.0 + IL_002d: ldarg.0 + IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_0033: ldc.i4.3 + IL_0034: sub + IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField + IL_003a: ret + } // end of method CompoundAssignmentTest::Enum + + .method public hidebysig instance void + ShortEnumTest() cil managed + { + // Code size 60 (0x3c) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldarg.0 + IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0008: ldc.i4.2 + IL_0009: or + IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_000f: ldarg.0 + IL_0010: ldarg.0 + IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0016: ldc.i4.4 + IL_0017: and + IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_001d: ldarg.0 + IL_001e: ldarg.0 + IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0024: ldc.i4.2 + IL_0025: add + IL_0026: conv.i2 + IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_002c: ldarg.0 + IL_002d: ldarg.0 + IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_0033: ldc.i4.3 + IL_0034: sub + IL_0035: conv.i2 + IL_0036: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField + IL_003b: ret + } // end of method CompoundAssignmentTest::ShortEnumTest + + .method public hidebysig instance int32 + PreIncrementInAddition(int32 i, + int32 j) cil managed + { + // Code size 14 (0xe) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldc.i4.1 + IL_0004: add + IL_0005: dup + IL_0006: starg.s j + IL_0008: add + IL_0009: stloc.0 + IL_000a: br.s IL_000c + + IL_000c: ldloc.0 + IL_000d: ret + } // end of method CompoundAssignmentTest::PreIncrementInAddition + + .method public hidebysig instance int32 + PreIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 21 (0x15) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldind.i4 + IL_000a: ldc.i4.1 + IL_000b: sub + IL_000c: stloc.0 + IL_000d: ldloc.0 + IL_000e: stind.i4 + IL_000f: ldloc.0 + IL_0010: stloc.1 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.1 + IL_0014: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElement + + .method public hidebysig instance int32 + PostIncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 21 (0x15) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldind.i4 + IL_000a: stloc.0 + IL_000b: ldloc.0 + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: stind.i4 + IL_000f: ldloc.0 + IL_0010: stloc.1 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.1 + IL_0014: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElement + + .method public hidebysig instance void + IncrementArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldind.i4 + IL_000a: ldc.i4.1 + IL_000b: add + IL_000c: stind.i4 + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementArrayElement + + .method public hidebysig instance void + DoubleArrayElement(int32[] 'array', + int32 pos) cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldind.i4 + IL_000a: ldc.i4.2 + IL_000b: mul + IL_000c: stind.i4 + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleArrayElement + + .method public hidebysig instance int32 + DoubleArrayElementAndReturn(int32[] 'array', + int32 pos) cil managed + { + // Code size 21 (0x15) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int32 + IL_0008: dup + IL_0009: ldind.i4 + IL_000a: ldc.i4.2 + IL_000b: mul + IL_000c: dup + IL_000d: stloc.0 + IL_000e: stind.i4 + IL_000f: ldloc.0 + IL_0010: stloc.1 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.1 + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + + .method public hidebysig instance int32 + PreIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 3 + .locals init (int16 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldind.i2 + IL_000a: ldc.i4.1 + IL_000b: sub + IL_000c: conv.i2 + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: stind.i2 + IL_0010: ldloc.0 + IL_0011: stloc.1 + IL_0012: br.s IL_0014 + + IL_0014: ldloc.1 + IL_0015: ret + } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + + .method public hidebysig instance int32 + PostIncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 3 + .locals init (int16 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldind.i2 + IL_000a: stloc.0 + IL_000b: ldloc.0 + IL_000c: ldc.i4.1 + IL_000d: add + IL_000e: conv.i2 + IL_000f: stind.i2 + IL_0010: ldloc.0 + IL_0011: stloc.1 + IL_0012: br.s IL_0014 + + IL_0014: ldloc.1 + IL_0015: ret + } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + + .method public hidebysig instance void + IncrementArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldind.i2 + IL_000a: ldc.i4.1 + IL_000b: add + IL_000c: conv.i2 + IL_000d: stind.i2 + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementArrayElementShort + + .method public hidebysig instance void + DoubleArrayElementShort(int16[] 'array', + int32 pos) cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldind.i2 + IL_000a: ldc.i4.2 + IL_000b: mul + IL_000c: conv.i2 + IL_000d: stind.i2 + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShort + + .method public hidebysig instance int16 + DoubleArrayElementShortAndReturn(int16[] 'array', + int32 pos) cil managed + { + // Code size 22 (0x16) + .maxstack 3 + .locals init (int16 V_0, + int16 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: ldarg.2 + IL_0003: ldelema [mscorlib]System.Int16 + IL_0008: dup + IL_0009: ldind.i2 + IL_000a: ldc.i4.2 + IL_000b: mul + IL_000c: conv.i2 + IL_000d: dup + IL_000e: stloc.0 + IL_000f: stind.i2 + IL_0010: ldloc.0 + IL_0011: stloc.1 + IL_0012: br.s IL_0014 + + IL_0014: ldloc.1 + IL_0015: ret + } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: stloc.0 + IL_0010: ldloc.0 + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.0 + IL_0017: stloc.1 + IL_0018: br.s IL_001a + + IL_001a: ldloc.1 + IL_001b: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField + + .method public hidebysig instance int32 + PostIncrementInstanceField() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.0 + IL_0017: stloc.1 + IL_0018: br.s IL_001a + + IL_001a: ldloc.1 + IL_001b: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField + + .method public hidebysig instance void + IncrementInstanceField() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0014: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField + + .method public hidebysig instance void + DoubleInstanceField() cil managed + { + // Code size 21 (0x15) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0014: ret + } // end of method CompoundAssignmentTest::DoubleInstanceField + + .method public hidebysig instance int32 + DoubleInstanceFieldAndReturn() cil managed + { + // Code size 28 (0x1c) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: dup + IL_0010: stloc.0 + IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0016: ldloc.0 + IL_0017: stloc.1 + IL_0018: br.s IL_001a + + IL_001a: ldloc.1 + IL_001b: ret + } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: stloc.0 + IL_000b: ldloc.0 + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0011: ldloc.0 + IL_0012: stloc.1 + IL_0013: br.s IL_0015 + + IL_0015: ldloc.1 + IL_0016: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + + .method public hidebysig instance int32 + PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: stloc.0 + IL_0009: ldloc.0 + IL_000a: ldc.i4.1 + IL_000b: add + IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0011: ldloc.0 + IL_0012: stloc.1 + IL_0013: br.s IL_0015 + + IL_0015: ldloc.1 + IL_0016: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + + .method public hidebysig instance void + IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.1 + IL_0002: dup + IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_0008: ldc.i4.1 + IL_0009: add + IL_000a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field + IL_000f: ret + } // end of method CompoundAssignmentTest::IncrementInstanceField2 + + .method public hidebysig instance int32 + PreIncrementInstanceFieldShort() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int16 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.i2 + IL_0010: stloc.0 + IL_0011: ldloc.0 + IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0017: ldloc.0 + IL_0018: stloc.1 + IL_0019: br.s IL_001b + + IL_001b: ldloc.1 + IL_001c: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + + .method public hidebysig instance int32 + PostIncrementInstanceFieldShort() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int16 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.i2 + IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0017: ldloc.0 + IL_0018: stloc.1 + IL_0019: br.s IL_001b + + IL_001b: ldloc.1 + IL_001c: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + + .method public hidebysig instance void + IncrementInstanceFieldShort() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.i2 + IL_0010: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField + IL_0015: ret + } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + + .method public hidebysig instance int32 + PreIncrementInstanceProperty() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: stloc.0 + IL_0010: ldloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.0 + IL_0018: stloc.1 + IL_0019: br.s IL_001b + + IL_001b: ldloc.1 + IL_001c: ret + } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + + .method public hidebysig instance int32 + PostIncrementInstanceProperty() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.0 + IL_0018: stloc.1 + IL_0019: br.s IL_001b + + IL_001b: ldloc.1 + IL_001c: ret + } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + + .method public hidebysig instance void + IncrementInstanceProperty() cil managed + { + // Code size 24 (0x18) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ret + } // end of method CompoundAssignmentTest::IncrementInstanceProperty + + .method public hidebysig instance void + DoubleInstanceProperty() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0014: nop + IL_0015: ret + } // end of method CompoundAssignmentTest::DoubleInstanceProperty + + .method public hidebysig instance int32 + DoubleInstancePropertyAndReturn() cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: dup + IL_0010: stloc.0 + IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0016: nop + IL_0017: ldloc.0 + IL_0018: stloc.1 + IL_0019: br.s IL_001b + + IL_001b: ldloc.1 + IL_001c: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + + .method public hidebysig instance int32 + PreIncrementInstancePropertyByte() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (uint8 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.u1 + IL_0010: stloc.0 + IL_0011: ldloc.0 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.0 + IL_0019: stloc.1 + IL_001a: br.s IL_001c + + IL_001c: ldloc.1 + IL_001d: ret + } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + + .method public hidebysig instance int32 + PostIncrementInstancePropertyByte() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (uint8 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.u1 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.0 + IL_0019: stloc.1 + IL_001a: br.s IL_001c + + IL_001c: ldloc.1 + IL_001d: ret + } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + + .method public hidebysig instance void + IncrementInstancePropertyByte() cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: stloc.0 + IL_000e: ldloc.0 + IL_000f: ldc.i4.1 + IL_0010: add + IL_0011: conv.u1 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ret + } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + + .method public hidebysig instance void + DoubleInstancePropertyByte() cil managed + { + // Code size 23 (0x17) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.u1 + IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0015: nop + IL_0016: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + + .method public hidebysig instance int32 + DoubleInstancePropertyByteAndReturn() cil managed + { + // Code size 30 (0x1e) + .maxstack 3 + .locals init (uint8 V_0, + int32 V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() + IL_0007: dup + IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() + IL_000d: ldc.i4.2 + IL_000e: mul + IL_000f: conv.u1 + IL_0010: dup + IL_0011: stloc.0 + IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) + IL_0017: nop + IL_0018: ldloc.0 + IL_0019: stloc.1 + IL_001a: br.s IL_001c + + IL_001c: ldloc.1 + IL_001d: ret + } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticField() cil managed + { + // Code size 19 (0x13) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticField + + .method public hidebysig instance int32 + PostIncrementStaticField() cil managed + { + // Code size 19 (0x13) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticField + + .method public hidebysig instance void + IncrementStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::IncrementStaticField + + .method public hidebysig instance void + DoubleStaticField() cil managed + { + // Code size 14 (0xe) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000d: ret + } // end of method CompoundAssignmentTest::DoubleStaticField + + .method public hidebysig instance int32 + DoubleStaticFieldAndReturn() cil managed + { + // Code size 19 (0x13) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField + IL_000e: stloc.0 + IL_000f: br.s IL_0011 + + IL_0011: ldloc.0 + IL_0012: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + + .method public hidebysig instance int32 + PreIncrementStaticFieldShort() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + + .method public hidebysig instance int32 + PostIncrementStaticFieldShort() cil managed + { + // Code size 20 (0x14) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + + .method public hidebysig instance void + IncrementStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + + .method public hidebysig instance void + DoubleStaticFieldShort() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + + .method public hidebysig instance int16 + DoubleStaticFieldAndReturnShort() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + + .method public hidebysig instance int32 + PreIncrementStaticProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + + .method public hidebysig instance int32 + PostIncrementStaticProperty() cil managed + { + // Code size 20 (0x14) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + + .method public hidebysig instance void + IncrementStaticProperty() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: nop + IL_000e: ret + } // end of method CompoundAssignmentTest::IncrementStaticProperty + + .method public hidebysig instance void + DoubleStaticProperty() cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000d: nop + IL_000e: ret + } // end of method CompoundAssignmentTest::DoubleStaticProperty + + .method public hidebysig instance int32 + DoubleStaticPropertyAndReturn() cil managed + { + // Code size 20 (0x14) + .maxstack 2 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() + IL_0006: ldc.i4.2 + IL_0007: mul + IL_0008: dup + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) + IL_000e: nop + IL_000f: stloc.0 + IL_0010: br.s IL_0012 + + IL_0012: ldloc.0 + IL_0013: ret + } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PreIncrementStaticPropertyShort() cil managed + { + // Code size 21 (0x15) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: dup + IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000f: nop + IL_0010: stloc.0 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.0 + IL_0014: ret + } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + + .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum + PostIncrementStaticPropertyShort() cil managed + { + // Code size 21 (0x15) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000f: nop + IL_0010: stloc.0 + IL_0011: br.s IL_0013 + + IL_0013: ldloc.0 + IL_0014: ret + } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + + .method public hidebysig instance void + IncrementStaticPropertyShort() cil managed + { + // Code size 16 (0x10) + .maxstack 8 + IL_0000: nop + IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) + IL_000e: nop + IL_000f: ret + } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + + .method public hidebysig static void ByteAddTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: add + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: add + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: add + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: add + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: add + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: add + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: add + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: add + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteAddTest + + .method public hidebysig static void ByteSubtractTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: sub + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: sub + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: sub + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: sub + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: sub + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: sub + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: sub + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: sub + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteSubtractTest + + .method public hidebysig static void ByteMultiplyTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: mul + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: mul + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: mul + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: mul + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: mul + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: mul + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: mul + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: mul + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteMultiplyTest + + .method public hidebysig static void ByteDivideTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: div + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: div + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: div + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: div + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: div + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: div + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: div + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: div + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: div + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: div + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteDivideTest + + .method public hidebysig static void ByteModulusTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: rem + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: rem + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: rem + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: rem + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: rem + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: rem + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: rem + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: rem + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: rem + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: rem + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteModulusTest + + .method public hidebysig static void ByteLeftShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: shl + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: shl + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: shl + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: shl + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: shl + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: shl + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: shl + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: shl + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteLeftShiftTest + + .method public hidebysig static void ByteRightShiftTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: shr + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: shr + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: shr + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: shr + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: shr + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: shr + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: shr + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: shr + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteRightShiftTest + + .method public hidebysig static void ByteBitAndTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: and + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: and + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: and + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: and + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: and + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: and + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: and + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: and + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteBitAndTest + + .method public hidebysig static void ByteBitOrTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: or + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: or + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: or + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: or + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: or + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: or + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: or + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: or + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteBitOrTest + + .method public hidebysig static void ByteBitXorTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.u1 + IL_0009: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000e: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.u1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.u1 + IL_0026: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.u1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0042: dup + IL_0043: ldind.u1 + IL_0044: ldc.i4.5 + IL_0045: xor + IL_0046: conv.u1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.u1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0064: ldc.i4.5 + IL_0065: xor + IL_0066: conv.u1 + IL_0067: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0077: ldc.i4.5 + IL_0078: xor + IL_0079: conv.u1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_008a: dup + IL_008b: ldind.u1 + IL_008c: ldc.i4.5 + IL_008d: xor + IL_008e: conv.u1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_009b: ldc.i4.5 + IL_009c: xor + IL_009d: conv.u1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.u1 + IL_00b2: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.u1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00d6: ldc.i4.5 + IL_00d7: xor + IL_00d8: conv.u1 + IL_00d9: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00e9: ldc.i4.5 + IL_00ea: xor + IL_00eb: conv.u1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00fc: dup + IL_00fd: ldind.u1 + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: conv.u1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: conv.u1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0115: nop + IL_0116: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_011b: dup + IL_011c: ldind.u1 + IL_011d: ldc.i4.5 + IL_011e: xor + IL_011f: conv.u1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::ByteBitXorTest + + .method public hidebysig static void BytePostIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.u1 + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.u1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.u1 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.u1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0062: dup + IL_0063: ldind.u1 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: add + IL_0068: conv.u1 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: add + IL_007d: conv.u1 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: add + IL_009a: conv.u1 + IL_009b: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: add + IL_00b6: conv.u1 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00ce: dup + IL_00cf: ldind.u1 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.u1 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: add + IL_00ec: conv.u1 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: conv.u1 + IL_010a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.u1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.u1 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: add + IL_015e: conv.u1 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0176: dup + IL_0177: ldind.u1 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: add + IL_017c: conv.u1 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.u1 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_01a7: dup + IL_01a8: ldind.u1 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: add + IL_01ad: conv.u1 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::BytePostIncTest + + .method public hidebysig static void BytePreIncTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u1 + IL_0009: dup + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.u1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.u1 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.u1 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0062: dup + IL_0063: ldind.u1 + IL_0064: ldc.i4.1 + IL_0065: add + IL_0066: conv.u1 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: conv.u1 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldc.i4.1 + IL_0097: add + IL_0098: conv.u1 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b2: ldc.i4.1 + IL_00b3: add + IL_00b4: conv.u1 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00ce: dup + IL_00cf: ldind.u1 + IL_00d0: ldc.i4.1 + IL_00d1: add + IL_00d2: conv.u1 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e8: ldc.i4.1 + IL_00e9: add + IL_00ea: conv.u1 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: conv.u1 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: conv.u1 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013e: ldc.i4.1 + IL_013f: add + IL_0140: conv.u1 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.u1 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0176: dup + IL_0177: ldind.u1 + IL_0178: ldc.i4.1 + IL_0179: add + IL_017a: conv.u1 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.u1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_01a7: dup + IL_01a8: ldind.u1 + IL_01a9: ldc.i4.1 + IL_01aa: add + IL_01ab: conv.u1 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::BytePreIncTest + + .method public hidebysig static void BytePostDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.u1 + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.u1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.u1 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.u1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0062: dup + IL_0063: ldind.u1 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: sub + IL_0068: conv.u1 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: sub + IL_007d: conv.u1 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: sub + IL_009a: conv.u1 + IL_009b: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: sub + IL_00b6: conv.u1 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00ce: dup + IL_00cf: ldind.u1 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.u1 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: sub + IL_00ec: conv.u1 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: conv.u1 + IL_010a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.u1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.u1 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: sub + IL_015e: conv.u1 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0176: dup + IL_0177: ldind.u1 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: sub + IL_017c: conv.u1 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.u1 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_01a7: dup + IL_01a8: ldind.u1 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: sub + IL_01ad: conv.u1 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::BytePostDecTest + + .method public hidebysig static void BytePreDecTest(uint8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint8 V_0) + IL_0000: nop + IL_0001: ldsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u1 + IL_0009: dup + IL_000a: stsfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::byteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.u1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.u1 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.u1 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0062: dup + IL_0063: ldind.u1 + IL_0064: ldc.i4.1 + IL_0065: sub + IL_0066: conv.u1 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: conv.u1 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0096: ldc.i4.1 + IL_0097: sub + IL_0098: conv.u1 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_00b2: ldc.i4.1 + IL_00b3: sub + IL_00b4: conv.u1 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_00ce: dup + IL_00cf: ldind.u1 + IL_00d0: ldc.i4.1 + IL_00d1: sub + IL_00d2: conv.u1 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_00e8: ldc.i4.1 + IL_00e9: sub + IL_00ea: conv.u1 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: conv.u1 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: conv.u1 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_013e: ldc.i4.1 + IL_013f: sub + IL_0140: conv.u1 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ByteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ByteProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.u1 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ByteProp(uint8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ByteField + IL_0176: dup + IL_0177: ldind.u1 + IL_0178: ldc.i4.1 + IL_0179: sub + IL_017a: conv.u1 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ByteProp() + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.u1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ByteProp(uint8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefByte() + IL_01a7: dup + IL_01a8: ldind.u1 + IL_01a9: ldc.i4.1 + IL_01aa: sub + IL_01ab: conv.u1 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::BytePreDecTest + + .method public hidebysig static void SbyteAddTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: add + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: add + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: add + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: add + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: add + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: add + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: add + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: add + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteAddTest + + .method public hidebysig static void SbyteSubtractTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: sub + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: sub + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: sub + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: sub + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: sub + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: sub + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: sub + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: sub + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteSubtractTest + + .method public hidebysig static void SbyteMultiplyTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: mul + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: mul + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: mul + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: mul + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: mul + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: mul + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: mul + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: mul + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteMultiplyTest + + .method public hidebysig static void SbyteDivideTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: div + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: div + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: div + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: div + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: div + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: div + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: div + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: div + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: div + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: div + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteDivideTest + + .method public hidebysig static void SbyteModulusTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: rem + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: rem + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: rem + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: rem + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: rem + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: rem + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: rem + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: rem + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: rem + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: rem + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteModulusTest + + .method public hidebysig static void SbyteLeftShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: shl + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: shl + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: shl + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: shl + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: shl + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: shl + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: shl + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: shl + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteLeftShiftTest + + .method public hidebysig static void SbyteRightShiftTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: shr + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: shr + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: shr + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: shr + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: shr + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: shr + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: shr + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: shr + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteRightShiftTest + + .method public hidebysig static void SbyteBitAndTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: and + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: and + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: and + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: and + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: and + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: and + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: and + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: and + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteBitAndTest + + .method public hidebysig static void SbyteBitOrTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: or + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: or + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: or + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: or + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: or + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: or + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: or + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: or + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteBitOrTest + + .method public hidebysig static void SbyteBitXorTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.i1 + IL_0009: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000e: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.i1 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.i1 + IL_0026: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.i1 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0042: dup + IL_0043: ldind.i1 + IL_0044: ldc.i4.5 + IL_0045: xor + IL_0046: conv.i1 + IL_0047: stind.i1 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.i1 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0064: ldc.i4.5 + IL_0065: xor + IL_0066: conv.i1 + IL_0067: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0077: ldc.i4.5 + IL_0078: xor + IL_0079: conv.i1 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_008a: dup + IL_008b: ldind.i1 + IL_008c: ldc.i4.5 + IL_008d: xor + IL_008e: conv.i1 + IL_008f: stind.i1 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_009b: ldc.i4.5 + IL_009c: xor + IL_009d: conv.i1 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.i1 + IL_00b2: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.i1 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00d6: ldc.i4.5 + IL_00d7: xor + IL_00d8: conv.i1 + IL_00d9: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00e9: ldc.i4.5 + IL_00ea: xor + IL_00eb: conv.i1 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00fc: dup + IL_00fd: ldind.i1 + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: conv.i1 + IL_0101: stind.i1 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: conv.i1 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0115: nop + IL_0116: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_011b: dup + IL_011c: ldind.i1 + IL_011d: ldc.i4.5 + IL_011e: xor + IL_011f: conv.i1 + IL_0120: stind.i1 + IL_0121: ret + } // end of method CompoundAssignmentTest::SbyteBitXorTest + + .method public hidebysig static void SbytePostIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i1 + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.i1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.i1 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.i1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0062: dup + IL_0063: ldind.i1 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: add + IL_0068: conv.i1 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: add + IL_007d: conv.i1 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: add + IL_009a: conv.i1 + IL_009b: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: add + IL_00b6: conv.i1 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00ce: dup + IL_00cf: ldind.i1 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.i1 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: add + IL_00ec: conv.i1 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: conv.i1 + IL_010a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.i1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.i1 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: add + IL_015e: conv.i1 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0176: dup + IL_0177: ldind.i1 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: add + IL_017c: conv.i1 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.i1 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_01a7: dup + IL_01a8: ldind.i1 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: add + IL_01ad: conv.i1 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::SbytePostIncTest - .method public hidebysig specialname static - void set_StaticProperty(int32 'value') cil managed + .method public hidebysig static void SbytePreIncTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticProperty + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i1 + IL_0009: dup + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.i1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.i1 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.i1 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0062: dup + IL_0063: ldind.i1 + IL_0064: ldc.i4.1 + IL_0065: add + IL_0066: conv.i1 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: conv.i1 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldc.i4.1 + IL_0097: add + IL_0098: conv.i1 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b2: ldc.i4.1 + IL_00b3: add + IL_00b4: conv.i1 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00ce: dup + IL_00cf: ldind.i1 + IL_00d0: ldc.i4.1 + IL_00d1: add + IL_00d2: conv.i1 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e8: ldc.i4.1 + IL_00e9: add + IL_00ea: conv.i1 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: conv.i1 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: conv.i1 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013e: ldc.i4.1 + IL_013f: add + IL_0140: conv.i1 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.i1 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0176: dup + IL_0177: ldind.i1 + IL_0178: ldc.i4.1 + IL_0179: add + IL_017a: conv.i1 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.i1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_01a7: dup + IL_01a8: ldind.i1 + IL_01a9: ldc.i4.1 + IL_01aa: add + IL_01ab: conv.i1 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::SbytePreIncTest - .method public hidebysig specialname static - valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - get_StaticShortProperty() cil managed + .method public hidebysig static void SbytePostDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 6 (0x6) - .maxstack 8 - IL_0000: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0005: ret - } // end of method CompoundAssignmentTest::get_StaticShortProperty + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.i1 + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.i1 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.i1 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.i1 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0062: dup + IL_0063: ldind.i1 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: sub + IL_0068: conv.i1 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: sub + IL_007d: conv.i1 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: sub + IL_009a: conv.i1 + IL_009b: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: sub + IL_00b6: conv.i1 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00ce: dup + IL_00cf: ldind.i1 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.i1 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: sub + IL_00ec: conv.i1 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: conv.i1 + IL_010a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.i1 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.i1 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: sub + IL_015e: conv.i1 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0176: dup + IL_0177: ldind.i1 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: sub + IL_017c: conv.i1 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.i1 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_01a7: dup + IL_01a8: ldind.i1 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: sub + IL_01ad: conv.i1 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::SbytePostDecTest - .method public hidebysig specialname static - void set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum 'value') cil managed + .method public hidebysig static void SbytePreDecTest(int8 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) - // Code size 7 (0x7) - .maxstack 8 - IL_0000: ldarg.0 - IL_0001: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::'k__BackingField' - IL_0006: ret - } // end of method CompoundAssignmentTest::set_StaticShortProperty + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int8 V_0) + IL_0000: nop + IL_0001: ldsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i1 + IL_0009: dup + IL_000a: stsfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::sbyteField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.i1 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.i1 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.i1 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0062: dup + IL_0063: ldind.i1 + IL_0064: ldc.i4.1 + IL_0065: sub + IL_0066: conv.i1 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i1 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: conv.i1 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0096: ldc.i4.1 + IL_0097: sub + IL_0098: conv.i1 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_00b2: ldc.i4.1 + IL_00b3: sub + IL_00b4: conv.i1 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_00ce: dup + IL_00cf: ldind.i1 + IL_00d0: ldc.i4.1 + IL_00d1: sub + IL_00d2: conv.i1 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i1 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_00e8: ldc.i4.1 + IL_00e9: sub + IL_00ea: conv.i1 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: conv.i1 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: conv.i1 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_013e: ldc.i4.1 + IL_013f: sub + IL_0140: conv.i1 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::SbyteField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_SbyteProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.i1 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_SbyteProp(int8) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::SbyteField + IL_0176: dup + IL_0177: ldind.i1 + IL_0178: ldc.i4.1 + IL_0179: sub + IL_017a: conv.i1 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i1 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_SbyteProp() + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.i1 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_SbyteProp(int8) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int8& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefSbyte() + IL_01a7: dup + IL_01a8: ldind.i1 + IL_01a9: ldc.i4.1 + IL_01aa: sub + IL_01ab: conv.i1 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i1 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::SbytePreDecTest - .method private hidebysig instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass - M() cil managed + .method public hidebysig static void ShortAddTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 11 (0xb) - .maxstack 1 - .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass V_0) + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::.ctor() - IL_0006: stloc.0 - IL_0007: br.s IL_0009 + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: add + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: add + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: add + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: add + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: add + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: add + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: add + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: add + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortAddTest - IL_0009: ldloc.0 - IL_000a: ret - } // end of method CompoundAssignmentTest::M + .method public hidebysig static void ShortSubtractTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: sub + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: sub + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: sub + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: sub + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: sub + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: sub + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: sub + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: sub + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortSubtractTest - .method private hidebysig instance int32[0...,0...] - Array() cil managed + .method public hidebysig static void ShortMultiplyTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 7 (0x7) - .maxstack 1 - .locals init (int32[0...,0...] V_0) + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldnull - IL_0002: stloc.0 - IL_0003: br.s IL_0005 + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: mul + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: mul + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: mul + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: mul + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: mul + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: mul + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: mul + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: mul + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortMultiplyTest - IL_0005: ldloc.0 - IL_0006: ret - } // end of method CompoundAssignmentTest::Array + .method public hidebysig static void ShortDivideTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: div + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: div + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: div + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: div + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: div + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: div + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: div + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: div + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: div + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: div + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortDivideTest - .method private hidebysig instance int32* - GetPointer() cil managed + .method public hidebysig static void ShortModulusTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 8 (0x8) - .maxstack 1 - .locals init (int32* V_0) + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: rem + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: rem + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: rem + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: rem + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: rem + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: rem + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: rem + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: rem + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: rem + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: rem + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortModulusTest + + .method public hidebysig static void ShortLeftShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: shl + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: shl + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: shl + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: shl + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: shl + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: shl + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: shl + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: shl + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortLeftShiftTest + + .method public hidebysig static void ShortRightShiftTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: shr + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: shr + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: shr + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: shr + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: shr + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: shr + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: shr + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: shr + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortRightShiftTest + + .method public hidebysig static void ShortBitAndTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: and + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: and + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: and + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: and + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: and + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: and + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: and + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: and + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortBitAndTest + + .method public hidebysig static void ShortBitOrTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: or + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: or + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: or + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: or + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: or + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: or + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: or + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: or + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortBitOrTest + + .method public hidebysig static void ShortBitXorTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.i2 + IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000e: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.i2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.i2 + IL_0026: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.i2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0042: dup + IL_0043: ldind.i2 + IL_0044: ldc.i4.5 + IL_0045: xor + IL_0046: conv.i2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.i2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0064: ldc.i4.5 + IL_0065: xor + IL_0066: conv.i2 + IL_0067: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0077: ldc.i4.5 + IL_0078: xor + IL_0079: conv.i2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_008a: dup + IL_008b: ldind.i2 + IL_008c: ldc.i4.5 + IL_008d: xor + IL_008e: conv.i2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_009b: ldc.i4.5 + IL_009c: xor + IL_009d: conv.i2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.i2 + IL_00b2: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.i2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00d6: ldc.i4.5 + IL_00d7: xor + IL_00d8: conv.i2 + IL_00d9: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00e9: ldc.i4.5 + IL_00ea: xor + IL_00eb: conv.i2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00fc: dup + IL_00fd: ldind.i2 + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: conv.i2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: conv.i2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0115: nop + IL_0116: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_011b: dup + IL_011c: ldind.i2 + IL_011d: ldc.i4.5 + IL_011e: xor + IL_011f: conv.i2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::ShortBitXorTest + + .method public hidebysig static void ShortPostIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.i2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.i2 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.i2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0062: dup + IL_0063: ldind.i2 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: add + IL_0068: conv.i2 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: add + IL_007d: conv.i2 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: add + IL_009a: conv.i2 + IL_009b: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: add + IL_00b6: conv.i2 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00ce: dup + IL_00cf: ldind.i2 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.i2 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: add + IL_00ec: conv.i2 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: conv.i2 + IL_010a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.i2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.i2 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: add + IL_015e: conv.i2 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0176: dup + IL_0177: ldind.i2 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: add + IL_017c: conv.i2 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.i2 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_01a7: dup + IL_01a8: ldind.i2 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: add + IL_01ad: conv.i2 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::ShortPostIncTest + + .method public hidebysig static void ShortPreIncTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.i2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.i2 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.i2 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0062: dup + IL_0063: ldind.i2 + IL_0064: ldc.i4.1 + IL_0065: add + IL_0066: conv.i2 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: conv.i2 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldc.i4.1 + IL_0097: add + IL_0098: conv.i2 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b2: ldc.i4.1 + IL_00b3: add + IL_00b4: conv.i2 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00ce: dup + IL_00cf: ldind.i2 + IL_00d0: ldc.i4.1 + IL_00d1: add + IL_00d2: conv.i2 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e8: ldc.i4.1 + IL_00e9: add + IL_00ea: conv.i2 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: conv.i2 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: conv.i2 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013e: ldc.i4.1 + IL_013f: add + IL_0140: conv.i2 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.i2 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0176: dup + IL_0177: ldind.i2 + IL_0178: ldc.i4.1 + IL_0179: add + IL_017a: conv.i2 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.i2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_01a7: dup + IL_01a8: ldind.i2 + IL_01a9: ldc.i4.1 + IL_01aa: add + IL_01ab: conv.i2 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::ShortPreIncTest + + .method public hidebysig static void ShortPostDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.i2 + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.i2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.i2 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.i2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0062: dup + IL_0063: ldind.i2 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: sub + IL_0068: conv.i2 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: sub + IL_007d: conv.i2 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: sub + IL_009a: conv.i2 + IL_009b: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: sub + IL_00b6: conv.i2 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00ce: dup + IL_00cf: ldind.i2 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.i2 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: sub + IL_00ec: conv.i2 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: conv.i2 + IL_010a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.i2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.i2 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: sub + IL_015e: conv.i2 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0176: dup + IL_0177: ldind.i2 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: sub + IL_017c: conv.i2 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.i2 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_01a7: dup + IL_01a8: ldind.i2 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: sub + IL_01ad: conv.i2 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::ShortPostDecTest + + .method public hidebysig static void ShortPreDecTest(int16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int16 V_0) + IL_0000: nop + IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.i2 + IL_0009: dup + IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.i2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.i2 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.i2 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0062: dup + IL_0063: ldind.i2 + IL_0064: ldc.i4.1 + IL_0065: sub + IL_0066: conv.i2 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: conv.i2 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0096: ldc.i4.1 + IL_0097: sub + IL_0098: conv.i2 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_00b2: ldc.i4.1 + IL_00b3: sub + IL_00b4: conv.i2 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_00ce: dup + IL_00cf: ldind.i2 + IL_00d0: ldc.i4.1 + IL_00d1: sub + IL_00d2: conv.i2 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_00e8: ldc.i4.1 + IL_00e9: sub + IL_00ea: conv.i2 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: conv.i2 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: conv.i2 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_013e: ldc.i4.1 + IL_013f: sub + IL_0140: conv.i2 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::ShortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_ShortProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.i2 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_ShortProp(int16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::ShortField + IL_0176: dup + IL_0177: ldind.i2 + IL_0178: ldc.i4.1 + IL_0179: sub + IL_017a: conv.i2 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_ShortProp() + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.i2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_ShortProp(int16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefShort() + IL_01a7: dup + IL_01a8: ldind.i2 + IL_01a9: ldc.i4.1 + IL_01aa: sub + IL_01ab: conv.i2 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::ShortPreDecTest + + .method public hidebysig static void UshortAddTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: add + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: add + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: add + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: add + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: add + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: add + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: add + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: add + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: add + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: add + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: add + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: add + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: add + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: add + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortAddTest + + .method public hidebysig static void UshortSubtractTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: sub + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: sub + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: sub + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: sub + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: sub + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: sub + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: sub + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: sub + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: sub + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: sub + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: sub + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: sub + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: sub + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: sub + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortSubtractTest + + .method public hidebysig static void UshortMultiplyTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: mul + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: mul + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: mul + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: mul + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: mul + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: mul + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: mul + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: mul + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: mul + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: mul + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: mul + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: mul + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: mul + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: mul + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortMultiplyTest + + .method public hidebysig static void UshortDivideTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: div + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: div + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: div + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: div + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: div + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: div + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: div + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: div + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: div + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: div + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: div + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: div + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: div + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: div + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: div + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: div + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortDivideTest + + .method public hidebysig static void UshortModulusTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldc.i4.0 - IL_0002: conv.u - IL_0003: stloc.0 - IL_0004: br.s IL_0006 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: rem + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: rem + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: rem + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: rem + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: rem + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: rem + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: rem + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: rem + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: rem + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: rem + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: rem + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: rem + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: rem + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: rem + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: rem + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: rem + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortModulusTest - IL_0006: ldloc.0 - IL_0007: ret - } // end of method CompoundAssignmentTest::GetPointer + .method public hidebysig static void UshortLeftShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: shl + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: shl + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: shl + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: shl + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: shl + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: shl + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: shl + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: shl + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: shl + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: shl + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shl + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: shl + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: shl + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: shl + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortLeftShiftTest - .method public hidebysig instance int32 - GetIndex() cil managed + .method public hidebysig static void UshortRightShiftTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: newobj instance void [mscorlib]System.Random::.ctor() - IL_0006: ldc.i4.0 - IL_0007: ldc.i4.s 100 - IL_0009: callvirt instance int32 [mscorlib]System.Random::Next(int32, - int32) - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: shr + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: shr + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: shr + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: shr + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: shr + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: shr + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: shr + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: shr + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: shr + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: shr + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: shr + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: shr + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: shr + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: shr + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortRightShiftTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::GetIndex + .method public hidebysig static void UshortBitAndTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: and + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: and + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: and + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: and + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: and + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: and + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: and + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: and + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: and + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: and + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: and + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: and + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: and + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: and + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortBitAndTest - .method public hidebysig instance int32[] - GetArray() cil managed + .method public hidebysig static void UshortBitOrTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 7 (0x7) - .maxstack 8 + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0006: throw - } // end of method CompoundAssignmentTest::GetArray + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: or + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: or + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: or + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: or + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: or + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: or + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: or + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: or + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: or + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: or + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: or + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: or + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: or + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: or + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortBitOrTest - .method public hidebysig instance int32 - GetValue(int32 'value') cil managed + .method public hidebysig static void UshortBitXorTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 7 (0x7) - .maxstack 1 - .locals init (int32 V_0) + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: stloc.0 - IL_0003: br.s IL_0005 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: conv.u2 + IL_0009: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000e: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_0013: ldc.i4.5 + IL_0014: xor + IL_0015: conv.u2 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0023: ldc.i4.5 + IL_0024: xor + IL_0025: conv.u2 + IL_0026: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0032: ldc.i4.5 + IL_0033: xor + IL_0034: conv.u2 + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0042: dup + IL_0043: ldind.u2 + IL_0044: ldc.i4.5 + IL_0045: xor + IL_0046: conv.u2 + IL_0047: stind.i2 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0050: ldc.i4.5 + IL_0051: xor + IL_0052: conv.u2 + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0064: ldc.i4.5 + IL_0065: xor + IL_0066: conv.u2 + IL_0067: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0077: ldc.i4.5 + IL_0078: xor + IL_0079: conv.u2 + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_008a: dup + IL_008b: ldind.u2 + IL_008c: ldc.i4.5 + IL_008d: xor + IL_008e: conv.u2 + IL_008f: stind.i2 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_009b: ldc.i4.5 + IL_009c: xor + IL_009d: conv.u2 + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00af: ldc.i4.5 + IL_00b0: xor + IL_00b1: conv.u2 + IL_00b2: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00c2: ldc.i4.5 + IL_00c3: xor + IL_00c4: conv.u2 + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00d6: ldc.i4.5 + IL_00d7: xor + IL_00d8: conv.u2 + IL_00d9: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00e9: ldc.i4.5 + IL_00ea: xor + IL_00eb: conv.u2 + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00fc: dup + IL_00fd: ldind.u2 + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: conv.u2 + IL_0101: stind.i2 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: conv.u2 + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0115: nop + IL_0116: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_011b: dup + IL_011c: ldind.u2 + IL_011d: ldc.i4.5 + IL_011e: xor + IL_011f: conv.u2 + IL_0120: stind.i2 + IL_0121: ret + } // end of method CompoundAssignmentTest::UshortBitXorTest - IL_0005: ldloc.0 - IL_0006: ret - } // end of method CompoundAssignmentTest::GetValue + .method public hidebysig static void UshortPostIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: conv.u2 + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: add + IL_001d: conv.u2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: add + IL_0035: conv.u2 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: add + IL_004d: conv.u2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0062: dup + IL_0063: ldind.u2 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: add + IL_0068: conv.u2 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: add + IL_007d: conv.u2 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: add + IL_009a: conv.u2 + IL_009b: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: add + IL_00b6: conv.u2 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00ce: dup + IL_00cf: ldind.u2 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: add + IL_00d4: conv.u2 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: add + IL_00ec: conv.u2 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: add + IL_0109: conv.u2 + IL_010a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: add + IL_0125: conv.u2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: add + IL_0142: conv.u2 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: add + IL_015e: conv.u2 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0176: dup + IL_0177: ldind.u2 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: add + IL_017c: conv.u2 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: add + IL_0194: conv.u2 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_01a7: dup + IL_01a8: ldind.u2 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: add + IL_01ad: conv.u2 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UshortPostIncTest - .method public hidebysig instance bool - IsUpperCaseA(char a) cil managed + .method public hidebysig static void UshortPreIncTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 11 (0xb) - .maxstack 2 - .locals init (bool V_0) + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint16 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.s 65 - IL_0004: ceq - IL_0006: stloc.0 - IL_0007: br.s IL_0009 + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: conv.u2 + IL_0009: dup + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: conv.u2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: conv.u2 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: ldc.i4.1 + IL_004a: add + IL_004b: conv.u2 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0062: dup + IL_0063: ldind.u2 + IL_0064: ldc.i4.1 + IL_0065: add + IL_0066: conv.u2 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0079: ldc.i4.1 + IL_007a: add + IL_007b: conv.u2 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldc.i4.1 + IL_0097: add + IL_0098: conv.u2 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b2: ldc.i4.1 + IL_00b3: add + IL_00b4: conv.u2 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00ce: dup + IL_00cf: ldind.u2 + IL_00d0: ldc.i4.1 + IL_00d1: add + IL_00d2: conv.u2 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e8: ldc.i4.1 + IL_00e9: add + IL_00ea: conv.u2 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0105: ldc.i4.1 + IL_0106: add + IL_0107: conv.u2 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0121: ldc.i4.1 + IL_0122: add + IL_0123: conv.u2 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013e: ldc.i4.1 + IL_013f: add + IL_0140: conv.u2 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: ldc.i4.1 + IL_015b: add + IL_015c: conv.u2 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0176: dup + IL_0177: ldind.u2 + IL_0178: ldc.i4.1 + IL_0179: add + IL_017a: conv.u2 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0190: ldc.i4.1 + IL_0191: add + IL_0192: conv.u2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_01a7: dup + IL_01a8: ldind.u2 + IL_01a9: ldc.i4.1 + IL_01aa: add + IL_01ab: conv.u2 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UshortPreIncTest - IL_0009: ldloc.0 - IL_000a: ret - } // end of method CompoundAssignmentTest::IsUpperCaseA + .method public hidebysig static void UshortPostDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint16 V_0) + IL_0000: nop + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: conv.u2 + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: sub + IL_001d: conv.u2 + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: sub + IL_0035: conv.u2 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: sub + IL_004d: conv.u2 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0062: dup + IL_0063: ldind.u2 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: sub + IL_0068: conv.u2 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: sub + IL_007d: conv.u2 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: sub + IL_009a: conv.u2 + IL_009b: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: sub + IL_00b6: conv.u2 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00ce: dup + IL_00cf: ldind.u2 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: sub + IL_00d4: conv.u2 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: sub + IL_00ec: conv.u2 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: sub + IL_0109: conv.u2 + IL_010a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: sub + IL_0125: conv.u2 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: sub + IL_0142: conv.u2 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: sub + IL_015e: conv.u2 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0176: dup + IL_0177: ldind.u2 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: sub + IL_017c: conv.u2 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: sub + IL_0194: conv.u2 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_01a7: dup + IL_01a8: ldind.u2 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: sub + IL_01ad: conv.u2 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UshortPostDecTest - .method public hidebysig instance void - Int32_Local_Add(int32 i) cil managed + .method public hidebysig static void UshortPreDecTest(uint16 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 48 (0x30) - .maxstack 8 + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint16 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.1 - IL_0003: add - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: dup - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ldarg.1 - IL_0013: ldc.i4.1 - IL_0014: add - IL_0015: dup - IL_0016: starg.s i - IL_0018: call void [mscorlib]System.Console::WriteLine(int32) - IL_001d: nop - IL_001e: ldarg.1 - IL_001f: ldc.i4.5 - IL_0020: add - IL_0021: starg.s i - IL_0023: ldarg.1 - IL_0024: ldc.i4.5 - IL_0025: add - IL_0026: dup - IL_0027: starg.s i - IL_0029: call void [mscorlib]System.Console::WriteLine(int32) - IL_002e: nop - IL_002f: ret - } // end of method CompoundAssignmentTest::Int32_Local_Add + IL_0001: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: conv.u2 + IL_0009: dup + IL_000a: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: conv.u2 + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: conv.u2 + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0049: ldc.i4.1 + IL_004a: sub + IL_004b: conv.u2 + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0062: dup + IL_0063: ldind.u2 + IL_0064: ldc.i4.1 + IL_0065: sub + IL_0066: conv.u2 + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i2 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0079: ldc.i4.1 + IL_007a: sub + IL_007b: conv.u2 + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0096: ldc.i4.1 + IL_0097: sub + IL_0098: conv.u2 + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_00b2: ldc.i4.1 + IL_00b3: sub + IL_00b4: conv.u2 + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_00ce: dup + IL_00cf: ldind.u2 + IL_00d0: ldc.i4.1 + IL_00d1: sub + IL_00d2: conv.u2 + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i2 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_00e8: ldc.i4.1 + IL_00e9: sub + IL_00ea: conv.u2 + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0105: ldc.i4.1 + IL_0106: sub + IL_0107: conv.u2 + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_0121: ldc.i4.1 + IL_0122: sub + IL_0123: conv.u2 + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_013e: ldc.i4.1 + IL_013f: sub + IL_0140: conv.u2 + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UshortField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UshortProp() + IL_015a: ldc.i4.1 + IL_015b: sub + IL_015c: conv.u2 + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UshortProp(uint16) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UshortField + IL_0176: dup + IL_0177: ldind.u2 + IL_0178: ldc.i4.1 + IL_0179: sub + IL_017a: conv.u2 + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i2 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UshortProp() + IL_0190: ldc.i4.1 + IL_0191: sub + IL_0192: conv.u2 + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UshortProp(uint16) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint16& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUshort() + IL_01a7: dup + IL_01a8: ldind.u2 + IL_01a9: ldc.i4.1 + IL_01aa: sub + IL_01ab: conv.u2 + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i2 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UshortPreDecTest - .method public hidebysig instance void - Int32_Local_Sub(int32 i) cil managed + .method public hidebysig static void IntAddTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 48 (0x30) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.1 - IL_0003: sub - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: dup - IL_0008: ldc.i4.1 - IL_0009: sub - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ldarg.1 - IL_0013: ldc.i4.1 - IL_0014: sub - IL_0015: dup - IL_0016: starg.s i - IL_0018: call void [mscorlib]System.Console::WriteLine(int32) - IL_001d: nop - IL_001e: ldarg.1 - IL_001f: ldc.i4.5 - IL_0020: sub - IL_0021: starg.s i - IL_0023: ldarg.1 - IL_0024: ldc.i4.5 - IL_0025: sub - IL_0026: dup - IL_0027: starg.s i - IL_0029: call void [mscorlib]System.Console::WriteLine(int32) - IL_002e: nop - IL_002f: ret - } // end of method CompoundAssignmentTest::Int32_Local_Sub + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: add + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: add + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: add + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: add + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: add + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: add + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: add + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: add + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: add + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: add + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntAddTest - .method public hidebysig instance void - Int32_Local_Mul(int32 i) cil managed + .method public hidebysig static void IntSubtractTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: mul - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: mul - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Mul + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: sub + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: sub + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: sub + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: sub + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: sub + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: sub + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: sub + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: sub + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: sub + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: sub + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntSubtractTest - .method public hidebysig instance void - Int32_Local_Div(int32 i) cil managed + .method public hidebysig static void IntMultiplyTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: div - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: div - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Div + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: mul + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: mul + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: mul + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: mul + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: mul + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: mul + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: mul + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: mul + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: mul + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: mul + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntMultiplyTest - .method public hidebysig instance void - Int32_Local_Rem(int32 i) cil managed + .method public hidebysig static void IntDivideTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: rem - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: rem - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_Rem + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: div + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: div + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: div + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: div + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: div + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: div + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: div + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: div + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: div + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: div + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: div + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: div + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: div + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: div + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: div + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: div + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: div + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntDivideTest - .method public hidebysig instance void - Int32_Local_BitAnd(int32 i) cil managed + .method public hidebysig static void IntModulusTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: and - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: and - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitAnd + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: rem + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: rem + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: rem + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: rem + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: rem + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: rem + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: rem + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: rem + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: rem + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: rem + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: rem + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: rem + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: rem + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: rem + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: rem + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: rem + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: rem + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntModulusTest - .method public hidebysig instance void - Int32_Local_BitOr(int32 i) cil managed + .method public hidebysig static void IntLeftShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: or - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: or - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitOr + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: shl + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: shl + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: shl + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: shl + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: shl + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: shl + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntLeftShiftTest - .method public hidebysig instance void - Int32_Local_BitXor(int32 i) cil managed + .method public hidebysig static void IntRightShiftTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: xor - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: xor - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_BitXor + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: shr + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: shr + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: shr + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: shr + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: shr + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: shr + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: shr + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: shr + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: shr + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntRightShiftTest - .method public hidebysig instance void - Int32_Local_ShiftLeft(int32 i) cil managed + .method public hidebysig static void IntBitAndTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: shl - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: shl - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftLeft + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: and + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: and + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: and + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: and + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: and + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: and + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: and + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: and + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: and + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: and + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntBitAndTest - .method public hidebysig instance void - Int32_Local_ShiftRight(int32 i) cil managed + .method public hidebysig static void IntBitOrTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: shr - IL_0004: starg.s i - IL_0006: ldarg.1 - IL_0007: ldc.i4.5 - IL_0008: shr - IL_0009: dup - IL_000a: starg.s i - IL_000c: call void [mscorlib]System.Console::WriteLine(int32) - IL_0011: nop - IL_0012: ret - } // end of method CompoundAssignmentTest::Int32_Local_ShiftRight + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: or + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: or + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: or + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: or + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: or + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: or + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: or + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: or + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: or + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: or + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntBitOrTest - .method public hidebysig instance void - IntegerWithInline(int32 i) cil managed + .method public hidebysig static void IntBitXorTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldc.i4.5 - IL_0003: add - IL_0004: dup - IL_0005: starg.s i - IL_0007: call void [mscorlib]System.Console::WriteLine(int32) - IL_000c: nop - IL_000d: ldarg.1 - IL_000e: call void [mscorlib]System.Console::WriteLine(int32) + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000d: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_002f: ldc.i4.5 + IL_0030: xor + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_003e: dup + IL_003f: ldind.i4 + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_004b: ldc.i4.5 + IL_004c: xor + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_005e: ldc.i4.5 + IL_005f: xor + IL_0060: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0070: ldc.i4.5 + IL_0071: xor + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0082: dup + IL_0083: ldind.i4 + IL_0084: ldc.i4.5 + IL_0085: xor + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0092: ldc.i4.5 + IL_0093: xor + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00a5: ldc.i4.5 + IL_00a6: xor + IL_00a7: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00b7: ldc.i4.5 + IL_00b8: xor + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00ca: ldc.i4.5 + IL_00cb: xor + IL_00cc: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00ee: dup + IL_00ef: ldind.i4 + IL_00f0: ldc.i4.5 + IL_00f1: xor + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_0105: nop + IL_0106: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_010b: dup + IL_010c: ldind.i4 + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::IntBitXorTest + + .method public hidebysig static void IntPostIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 422 (0x1a6) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) IL_0013: nop - IL_0014: ret - } // end of method CompoundAssignmentTest::IntegerWithInline + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: stloc.0 + IL_0047: ldloc.0 + IL_0048: ldc.i4.1 + IL_0049: add + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005e: dup + IL_005f: ldind.i4 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: ldc.i4.1 + IL_0063: add + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ab: stloc.0 + IL_00ac: ldloc.0 + IL_00ad: ldc.i4.1 + IL_00ae: add + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c6: dup + IL_00c7: ldind.i4 + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: ldc.i4.1 + IL_00cb: add + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: ldc.i4.1 + IL_00e2: add + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00fb: stloc.0 + IL_00fc: ldloc.0 + IL_00fd: ldc.i4.1 + IL_00fe: add + IL_00ff: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0116: stloc.0 + IL_0117: ldloc.0 + IL_0118: ldc.i4.1 + IL_0119: add + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0132: stloc.0 + IL_0133: ldloc.0 + IL_0134: ldc.i4.1 + IL_0135: add + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: stloc.0 + IL_014e: ldloc.0 + IL_014f: ldc.i4.1 + IL_0150: add + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0168: dup + IL_0169: ldind.i4 + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: add + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0181: stloc.0 + IL_0182: ldloc.0 + IL_0183: ldc.i4.1 + IL_0184: add + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0197: dup + IL_0198: ldind.i4 + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: ldc.i4.1 + IL_019c: add + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::IntPostIncTest - .method public hidebysig instance void - IntegerField(int32 i) cil managed + .method public hidebysig static void IntPreIncTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 72 (0x48) + // Code size 422 (0x1a6) .maxstack 3 .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldarg.0 - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0008: ldarg.1 - IL_0009: add - IL_000a: dup - IL_000b: stloc.0 - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0011: ldloc.0 - IL_0012: call void [mscorlib]System.Console::WriteLine(int32) - IL_0017: nop - IL_0018: ldarg.0 - IL_0019: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_001e: call void [mscorlib]System.Console::WriteLine(int32) - IL_0023: nop - IL_0024: ldarg.0 - IL_0025: ldarg.0 - IL_0026: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_002b: ldarg.1 - IL_002c: sub - IL_002d: dup - IL_002e: stloc.0 - IL_002f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0034: ldloc.0 - IL_0035: call void [mscorlib]System.Console::WriteLine(int32) - IL_003a: nop - IL_003b: ldarg.0 - IL_003c: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::test1 - IL_0041: call void [mscorlib]System.Console::WriteLine(int32) - IL_0046: nop - IL_0047: ret - } // end of method CompoundAssignmentTest::IntegerField + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.1 + IL_0007: add + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: stloc.0 + IL_0049: ldloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005e: dup + IL_005f: ldind.i4 + IL_0060: ldc.i4.1 + IL_0061: add + IL_0062: stloc.0 + IL_0063: ldloc.0 + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: stloc.0 + IL_0077: ldloc.0 + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0090: ldc.i4.1 + IL_0091: add + IL_0092: stloc.0 + IL_0093: ldloc.0 + IL_0094: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ab: ldc.i4.1 + IL_00ac: add + IL_00ad: stloc.0 + IL_00ae: ldloc.0 + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c6: dup + IL_00c7: ldind.i4 + IL_00c8: ldc.i4.1 + IL_00c9: add + IL_00ca: stloc.0 + IL_00cb: ldloc.0 + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00df: ldc.i4.1 + IL_00e0: add + IL_00e1: stloc.0 + IL_00e2: ldloc.0 + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00fb: ldc.i4.1 + IL_00fc: add + IL_00fd: stloc.0 + IL_00fe: ldloc.0 + IL_00ff: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0116: ldc.i4.1 + IL_0117: add + IL_0118: stloc.0 + IL_0119: ldloc.0 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0132: ldc.i4.1 + IL_0133: add + IL_0134: stloc.0 + IL_0135: ldloc.0 + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: ldc.i4.1 + IL_014e: add + IL_014f: stloc.0 + IL_0150: ldloc.0 + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0168: dup + IL_0169: ldind.i4 + IL_016a: ldc.i4.1 + IL_016b: add + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0181: ldc.i4.1 + IL_0182: add + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0197: dup + IL_0198: ldind.i4 + IL_0199: ldc.i4.1 + IL_019a: add + IL_019b: stloc.0 + IL_019c: ldloc.0 + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::IntPreIncTest - .method public hidebysig instance void - Array(int32 i) cil managed + .method public hidebysig static void IntPostDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 58 (0x3a) - .maxstack 4 + // Code size 422 (0x1a6) + .maxstack 3 .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0007: ldarg.1 - IL_0008: ldelema [mscorlib]System.Int32 - IL_000d: dup - IL_000e: ldind.i4 - IL_000f: ldarg.1 - IL_0010: add - IL_0011: dup - IL_0012: stloc.0 - IL_0013: stind.i4 - IL_0014: ldloc.0 - IL_0015: call void [mscorlib]System.Console::WriteLine(int32) - IL_001a: nop - IL_001b: ldarg.0 - IL_001c: ldfld int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::array1 - IL_0021: ldarg.1 - IL_0022: ldc.i4.2 - IL_0023: mul - IL_0024: ldelema [mscorlib]System.Int32 + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 IL_0029: dup - IL_002a: ldind.i4 - IL_002b: ldarg.1 - IL_002c: ldc.i4.2 - IL_002d: mul - IL_002e: add - IL_002f: dup - IL_0030: stloc.0 - IL_0031: stind.i4 + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: stloc.0 + IL_0047: ldloc.0 + IL_0048: ldc.i4.1 + IL_0049: sub + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005e: dup + IL_005f: ldind.i4 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: ldc.i4.1 + IL_0063: sub + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ab: stloc.0 + IL_00ac: ldloc.0 + IL_00ad: ldc.i4.1 + IL_00ae: sub + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c6: dup + IL_00c7: ldind.i4 + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: ldc.i4.1 + IL_00cb: sub + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: ldc.i4.1 + IL_00e2: sub + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00fb: stloc.0 + IL_00fc: ldloc.0 + IL_00fd: ldc.i4.1 + IL_00fe: sub + IL_00ff: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0116: stloc.0 + IL_0117: ldloc.0 + IL_0118: ldc.i4.1 + IL_0119: sub + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0132: stloc.0 + IL_0133: ldloc.0 + IL_0134: ldc.i4.1 + IL_0135: sub + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: stloc.0 + IL_014e: ldloc.0 + IL_014f: ldc.i4.1 + IL_0150: sub + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0168: dup + IL_0169: ldind.i4 + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: sub + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0181: stloc.0 + IL_0182: ldloc.0 + IL_0183: ldc.i4.1 + IL_0184: sub + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0197: dup + IL_0198: ldind.i4 + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: ldc.i4.1 + IL_019c: sub + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::IntPostDecTest + + .method public hidebysig static void IntPreDecTest(int32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 422 (0x1a6) + .maxstack 3 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_0006: ldc.i4.1 + IL_0007: sub + IL_0008: dup + IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::intField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: stloc.0 IL_0032: ldloc.0 - IL_0033: call void [mscorlib]System.Console::WriteLine(int32) - IL_0038: nop - IL_0039: ret - } // end of method CompoundAssignmentTest::Array + IL_0033: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: stloc.0 + IL_0049: ldloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_005e: dup + IL_005f: ldind.i4 + IL_0060: ldc.i4.1 + IL_0061: sub + IL_0062: stloc.0 + IL_0063: ldloc.0 + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: stloc.0 + IL_0077: ldloc.0 + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0090: ldc.i4.1 + IL_0091: sub + IL_0092: stloc.0 + IL_0093: ldloc.0 + IL_0094: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_00ab: ldc.i4.1 + IL_00ac: sub + IL_00ad: stloc.0 + IL_00ae: ldloc.0 + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_00c6: dup + IL_00c7: ldind.i4 + IL_00c8: ldc.i4.1 + IL_00c9: sub + IL_00ca: stloc.0 + IL_00cb: ldloc.0 + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_00df: ldc.i4.1 + IL_00e0: sub + IL_00e1: stloc.0 + IL_00e2: ldloc.0 + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_00fb: ldc.i4.1 + IL_00fc: sub + IL_00fd: stloc.0 + IL_00fe: ldloc.0 + IL_00ff: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_0116: ldc.i4.1 + IL_0117: sub + IL_0118: stloc.0 + IL_0119: ldloc.0 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_0132: ldc.i4.1 + IL_0133: sub + IL_0134: stloc.0 + IL_0135: ldloc.0 + IL_0136: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::IntField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_IntProp() + IL_014d: ldc.i4.1 + IL_014e: sub + IL_014f: stloc.0 + IL_0150: ldloc.0 + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_IntProp(int32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::IntField + IL_0168: dup + IL_0169: ldind.i4 + IL_016a: ldc.i4.1 + IL_016b: sub + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_IntProp() + IL_0181: ldc.i4.1 + IL_0182: sub + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_IntProp(int32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call int32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefInt() + IL_0197: dup + IL_0198: ldind.i4 + IL_0199: ldc.i4.1 + IL_019a: sub + IL_019b: stloc.0 + IL_019c: ldloc.0 + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::IntPreDecTest - .method public hidebysig instance int32 - ArrayUsageWithMethods() cil managed + .method public hidebysig static void UintAddTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 31 (0x1f) + // Code size 273 (0x111) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance int32[] ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetArray() - IL_0007: ldarg.0 - IL_0008: call instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetIndex() - IL_000d: ldelema [mscorlib]System.Int32 - IL_0012: dup - IL_0013: ldind.i4 - IL_0014: stloc.0 - IL_0015: ldloc.0 - IL_0016: ldc.i4.1 - IL_0017: add - IL_0018: stind.i4 - IL_0019: ldloc.0 - IL_001a: stloc.1 - IL_001b: br.s IL_001d + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: add + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: add + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: add + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: add + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: add + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: add + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: add + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: add + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: add + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: add + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: add + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: add + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: add + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: add + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: add + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: add + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: add + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintAddTest - IL_001d: ldloc.1 - IL_001e: ret - } // end of method CompoundAssignmentTest::ArrayUsageWithMethods + .method public hidebysig static void UintSubtractTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 273 (0x111) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: sub + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: sub + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: sub + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: sub + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: sub + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: sub + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: sub + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: sub + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: sub + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: sub + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: sub + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: sub + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: sub + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: sub + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: sub + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: sub + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: sub + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintSubtractTest - .method public hidebysig instance void - NestedField() cil managed + .method public hidebysig static void UintMultiplyTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 85 (0x55) + // Code size 273 (0x111) .maxstack 3 - .locals init (bool V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0007: ldfld bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::HasIndex - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: brfalse.s IL_0054 - - IL_0010: nop - IL_0011: ldarg.0 - IL_0012: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0017: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_001c: dup - IL_001d: ldind.i4 - IL_001e: ldc.i4.2 - IL_001f: mul - IL_0020: dup - IL_0021: stloc.1 - IL_0022: stind.i4 - IL_0023: ldloc.1 - IL_0024: call void [mscorlib]System.Console::WriteLine(int32) - IL_0029: nop - IL_002a: ldarg.0 - IL_002b: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0030: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field - IL_0035: dup - IL_0036: ldind.i4 - IL_0037: ldc.i4.1 - IL_0038: add - IL_0039: stind.i4 - IL_003a: ldarg.0 - IL_003b: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::field1 - IL_0040: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/StructContainer::Field + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: mul + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: mul + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: mul + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: mul + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: mul + IL_0042: stind.i4 + IL_0043: ldarga.s s IL_0045: dup - IL_0046: ldind.i4 - IL_0047: stloc.1 - IL_0048: ldloc.1 - IL_0049: ldc.i4.1 - IL_004a: add - IL_004b: stind.i4 - IL_004c: ldloc.1 - IL_004d: call void [mscorlib]System.Console::WriteLine(int32) + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: mul + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) IL_0052: nop - IL_0053: nop - IL_0054: ret - } // end of method CompoundAssignmentTest::NestedField + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: mul + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: mul + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: mul + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: mul + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: mul + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: mul + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: mul + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: mul + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: mul + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: mul + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: mul + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintMultiplyTest - .method public hidebysig instance void - Enum() cil managed + .method public hidebysig static void UintDivideTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 59 (0x3b) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldarg.0 - IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0008: ldc.i4.2 - IL_0009: or - IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_000f: ldarg.0 - IL_0010: ldarg.0 - IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0016: ldc.i4.s -5 - IL_0018: and - IL_0019: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_001e: ldarg.0 - IL_001f: ldarg.0 - IL_0020: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0025: ldc.i4.2 - IL_0026: add - IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_002c: ldarg.0 - IL_002d: ldarg.0 - IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_0033: ldc.i4.3 - IL_0034: sub - IL_0035: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MyEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::enumField - IL_003a: ret - } // end of method CompoundAssignmentTest::Enum + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: div.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: div.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: div.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: div.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: div.un + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: div.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: div.un + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: div.un + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: div.un + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: div.un + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: div.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: div.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: div.un + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: div.un + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: div.un + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: div.un + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: div.un + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintDivideTest - .method public hidebysig instance void - ShortEnumTest() cil managed + .method public hidebysig static void UintModulusTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 60 (0x3c) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: ldarg.0 - IL_0003: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0008: ldc.i4.2 - IL_0009: or - IL_000a: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_000f: ldarg.0 - IL_0010: ldarg.0 - IL_0011: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0016: ldc.i4.4 - IL_0017: and - IL_0018: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_001d: ldarg.0 - IL_001e: ldarg.0 - IL_001f: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0024: ldc.i4.2 - IL_0025: add - IL_0026: conv.i2 - IL_0027: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_002c: ldarg.0 - IL_002d: ldarg.0 - IL_002e: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_0033: ldc.i4.3 - IL_0034: sub - IL_0035: conv.i2 - IL_0036: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::shortEnumField - IL_003b: ret - } // end of method CompoundAssignmentTest::ShortEnumTest + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: rem.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: rem.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: rem.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: rem.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: rem.un + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: rem.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: rem.un + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: rem.un + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: rem.un + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: rem.un + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: rem.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: rem.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: rem.un + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: rem.un + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: rem.un + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: rem.un + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: rem.un + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintModulusTest - .method public hidebysig instance int32 - PreIncrementInAddition(int32 i, - int32 j) cil managed + .method public hidebysig static void UintLeftShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) + // Code size 273 (0x111) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldc.i4.1 - IL_0004: add - IL_0005: dup - IL_0006: starg.s j - IL_0008: add - IL_0009: stloc.0 - IL_000a: br.s IL_000c + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: shl + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: shl + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: shl + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: shl + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: shl + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: shl + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintLeftShiftTest - IL_000c: ldloc.0 - IL_000d: ret - } // end of method CompoundAssignmentTest::PreIncrementInAddition + .method public hidebysig static void UintRightShiftTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 273 (0x111) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: shr.un + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: shr.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: shr.un + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: shr.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: shr.un + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: shr.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: shr.un + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: shr.un + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: shr.un + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: shr.un + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: shr.un + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: shr.un + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: shr.un + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: shr.un + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: shr.un + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: shr.un + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintRightShiftTest - .method public hidebysig instance int32 - PreIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintBitAndTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) + // Code size 273 (0x111) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldind.i4 - IL_000a: ldc.i4.1 - IL_000b: sub - IL_000c: stloc.0 - IL_000d: ldloc.0 - IL_000e: stind.i4 - IL_000f: ldloc.0 - IL_0010: stloc.1 - IL_0011: br.s IL_0013 + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: and + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: and + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: and + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: and + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: and + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: and + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: and + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: and + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: and + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: and + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: and + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: and + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: and + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: and + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: and + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: and + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: and + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintBitAndTest - IL_0013: ldloc.1 - IL_0014: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElement + .method public hidebysig static void UintBitOrTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 273 (0x111) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: or + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: or + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: or + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: or + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: or + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: or + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: or + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: or + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: or + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: or + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: or + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: or + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: or + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: or + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: or + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: or + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: or + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintBitOrTest - .method public hidebysig instance int32 - PostIncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintBitXorTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) + // Code size 273 (0x111) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldind.i4 - IL_000a: stloc.0 - IL_000b: ldloc.0 - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: stind.i4 - IL_000f: ldloc.0 - IL_0010: stloc.1 - IL_0011: br.s IL_0013 + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.5 + IL_0007: xor + IL_0008: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000d: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0012: ldc.i4.5 + IL_0013: xor + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0021: ldc.i4.5 + IL_0022: xor + IL_0023: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_002f: ldc.i4.5 + IL_0030: xor + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_003e: dup + IL_003f: ldind.u4 + IL_0040: ldc.i4.5 + IL_0041: xor + IL_0042: stind.i4 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_004b: ldc.i4.5 + IL_004c: xor + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_005e: ldc.i4.5 + IL_005f: xor + IL_0060: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0070: ldc.i4.5 + IL_0071: xor + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0082: dup + IL_0083: ldind.u4 + IL_0084: ldc.i4.5 + IL_0085: xor + IL_0086: stind.i4 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0092: ldc.i4.5 + IL_0093: xor + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00a5: ldc.i4.5 + IL_00a6: xor + IL_00a7: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00b7: ldc.i4.5 + IL_00b8: xor + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00ca: ldc.i4.5 + IL_00cb: xor + IL_00cc: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00dc: ldc.i4.5 + IL_00dd: xor + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00ee: dup + IL_00ef: ldind.u4 + IL_00f0: ldc.i4.5 + IL_00f1: xor + IL_00f2: stind.i4 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00fe: ldc.i4.5 + IL_00ff: xor + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_0105: nop + IL_0106: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_010b: dup + IL_010c: ldind.u4 + IL_010d: ldc.i4.5 + IL_010e: xor + IL_010f: stind.i4 + IL_0110: ret + } // end of method CompoundAssignmentTest::UintBitXorTest - IL_0013: ldloc.1 - IL_0014: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElement + .method public hidebysig static void UintPostIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 422 (0x1a6) + .maxstack 3 + .locals init (uint32 V_0) + IL_0000: nop + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: add + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: add + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldc.i4.1 + IL_0032: add + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: stloc.0 + IL_0047: ldloc.0 + IL_0048: ldc.i4.1 + IL_0049: add + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005e: dup + IL_005f: ldind.u4 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: ldc.i4.1 + IL_0063: add + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: ldc.i4.1 + IL_0077: add + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: ldc.i4.1 + IL_0093: add + IL_0094: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ab: stloc.0 + IL_00ac: ldloc.0 + IL_00ad: ldc.i4.1 + IL_00ae: add + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c6: dup + IL_00c7: ldind.u4 + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: ldc.i4.1 + IL_00cb: add + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: ldc.i4.1 + IL_00e2: add + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00fb: stloc.0 + IL_00fc: ldloc.0 + IL_00fd: ldc.i4.1 + IL_00fe: add + IL_00ff: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0116: stloc.0 + IL_0117: ldloc.0 + IL_0118: ldc.i4.1 + IL_0119: add + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0132: stloc.0 + IL_0133: ldloc.0 + IL_0134: ldc.i4.1 + IL_0135: add + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: stloc.0 + IL_014e: ldloc.0 + IL_014f: ldc.i4.1 + IL_0150: add + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0168: dup + IL_0169: ldind.u4 + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: add + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0181: stloc.0 + IL_0182: ldloc.0 + IL_0183: ldc.i4.1 + IL_0184: add + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0197: dup + IL_0198: ldind.u4 + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: ldc.i4.1 + IL_019c: add + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::UintPostIncTest - .method public hidebysig instance void - IncrementArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintPreIncTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 422 (0x1a6) + .maxstack 3 + .locals init (uint32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.1 + IL_0007: add IL_0008: dup - IL_0009: ldind.i4 - IL_000a: ldc.i4.1 - IL_000b: add - IL_000c: stind.i4 - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementArrayElement + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: ldc.i4.1 + IL_001a: add + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: ldc.i4.1 + IL_0030: add + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: ldc.i4.1 + IL_0047: add + IL_0048: stloc.0 + IL_0049: ldloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005e: dup + IL_005f: ldind.u4 + IL_0060: ldc.i4.1 + IL_0061: add + IL_0062: stloc.0 + IL_0063: ldloc.0 + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0074: ldc.i4.1 + IL_0075: add + IL_0076: stloc.0 + IL_0077: ldloc.0 + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0090: ldc.i4.1 + IL_0091: add + IL_0092: stloc.0 + IL_0093: ldloc.0 + IL_0094: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ab: ldc.i4.1 + IL_00ac: add + IL_00ad: stloc.0 + IL_00ae: ldloc.0 + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c6: dup + IL_00c7: ldind.u4 + IL_00c8: ldc.i4.1 + IL_00c9: add + IL_00ca: stloc.0 + IL_00cb: ldloc.0 + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00df: ldc.i4.1 + IL_00e0: add + IL_00e1: stloc.0 + IL_00e2: ldloc.0 + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00fb: ldc.i4.1 + IL_00fc: add + IL_00fd: stloc.0 + IL_00fe: ldloc.0 + IL_00ff: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0116: ldc.i4.1 + IL_0117: add + IL_0118: stloc.0 + IL_0119: ldloc.0 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0132: ldc.i4.1 + IL_0133: add + IL_0134: stloc.0 + IL_0135: ldloc.0 + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: ldc.i4.1 + IL_014e: add + IL_014f: stloc.0 + IL_0150: ldloc.0 + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0168: dup + IL_0169: ldind.u4 + IL_016a: ldc.i4.1 + IL_016b: add + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0181: ldc.i4.1 + IL_0182: add + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0197: dup + IL_0198: ldind.u4 + IL_0199: ldc.i4.1 + IL_019a: add + IL_019b: stloc.0 + IL_019c: ldloc.0 + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::UintPreIncTest - .method public hidebysig instance void - DoubleArrayElement(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintPostDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 422 (0x1a6) + .maxstack 3 + .locals init (uint32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 - IL_0008: dup - IL_0009: ldind.i4 - IL_000a: ldc.i4.2 - IL_000b: mul - IL_000c: stind.i4 - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleArrayElement + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: sub + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: dup + IL_001a: ldc.i4.1 + IL_001b: sub + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: stloc.0 + IL_0030: ldloc.0 + IL_0031: ldc.i4.1 + IL_0032: sub + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: stloc.0 + IL_0047: ldloc.0 + IL_0048: ldc.i4.1 + IL_0049: sub + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005e: dup + IL_005f: ldind.u4 + IL_0060: stloc.0 + IL_0061: ldloc.0 + IL_0062: ldc.i4.1 + IL_0063: sub + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0074: stloc.0 + IL_0075: ldloc.0 + IL_0076: ldc.i4.1 + IL_0077: sub + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: ldc.i4.1 + IL_0093: sub + IL_0094: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ab: stloc.0 + IL_00ac: ldloc.0 + IL_00ad: ldc.i4.1 + IL_00ae: sub + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c6: dup + IL_00c7: ldind.u4 + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: ldc.i4.1 + IL_00cb: sub + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00df: stloc.0 + IL_00e0: ldloc.0 + IL_00e1: ldc.i4.1 + IL_00e2: sub + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00fb: stloc.0 + IL_00fc: ldloc.0 + IL_00fd: ldc.i4.1 + IL_00fe: sub + IL_00ff: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0116: stloc.0 + IL_0117: ldloc.0 + IL_0118: ldc.i4.1 + IL_0119: sub + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0132: stloc.0 + IL_0133: ldloc.0 + IL_0134: ldc.i4.1 + IL_0135: sub + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: stloc.0 + IL_014e: ldloc.0 + IL_014f: ldc.i4.1 + IL_0150: sub + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0168: dup + IL_0169: ldind.u4 + IL_016a: stloc.0 + IL_016b: ldloc.0 + IL_016c: ldc.i4.1 + IL_016d: sub + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0181: stloc.0 + IL_0182: ldloc.0 + IL_0183: ldc.i4.1 + IL_0184: sub + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0197: dup + IL_0198: ldind.u4 + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: ldc.i4.1 + IL_019c: sub + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::UintPostDecTest - .method public hidebysig instance int32 - DoubleArrayElementAndReturn(int32[] 'array', - int32 pos) cil managed + .method public hidebysig static void UintPreDecTest(uint32 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) + // Code size 422 (0x1a6) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (uint32 V_0) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int32 + IL_0001: ldsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_0006: ldc.i4.1 + IL_0007: sub IL_0008: dup - IL_0009: ldind.i4 - IL_000a: ldc.i4.2 - IL_000b: mul - IL_000c: dup - IL_000d: stloc.0 - IL_000e: stind.i4 - IL_000f: ldloc.0 - IL_0010: stloc.1 - IL_0011: br.s IL_0013 + IL_0009: stsfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::uintField + IL_000e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0013: nop + IL_0014: call uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + IL_0019: ldc.i4.1 + IL_001a: sub + IL_001b: dup + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + IL_0021: nop + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0027: nop + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_002f: ldc.i4.1 + IL_0030: sub + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0038: ldloc.0 + IL_0039: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_003e: nop + IL_003f: ldarg.1 + IL_0040: dup + IL_0041: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0046: ldc.i4.1 + IL_0047: sub + IL_0048: stloc.0 + IL_0049: ldloc.0 + IL_004a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_004f: nop + IL_0050: ldloc.0 + IL_0051: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0056: nop + IL_0057: ldarga.s s + IL_0059: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_005e: dup + IL_005f: ldind.u4 + IL_0060: ldc.i4.1 + IL_0061: sub + IL_0062: stloc.0 + IL_0063: ldloc.0 + IL_0064: stind.i4 + IL_0065: ldloc.0 + IL_0066: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_006b: nop + IL_006c: ldarga.s s + IL_006e: dup + IL_006f: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0074: ldc.i4.1 + IL_0075: sub + IL_0076: stloc.0 + IL_0077: ldloc.0 + IL_0078: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_007d: nop + IL_007e: ldloc.0 + IL_007f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0084: nop + IL_0085: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008a: dup + IL_008b: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0090: ldc.i4.1 + IL_0091: sub + IL_0092: stloc.0 + IL_0093: ldloc.0 + IL_0094: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0099: ldloc.0 + IL_009a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009f: nop + IL_00a0: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a5: dup + IL_00a6: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_00ab: ldc.i4.1 + IL_00ac: sub + IL_00ad: stloc.0 + IL_00ae: ldloc.0 + IL_00af: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_00b4: nop + IL_00b5: ldloc.0 + IL_00b6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bb: nop + IL_00bc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c1: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_00c6: dup + IL_00c7: ldind.u4 + IL_00c8: ldc.i4.1 + IL_00c9: sub + IL_00ca: stloc.0 + IL_00cb: ldloc.0 + IL_00cc: stind.i4 + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: dup + IL_00da: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_00df: ldc.i4.1 + IL_00e0: sub + IL_00e1: stloc.0 + IL_00e2: ldloc.0 + IL_00e3: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_00e8: nop + IL_00e9: ldloc.0 + IL_00ea: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ef: nop + IL_00f0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00f5: dup + IL_00f6: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_00fb: ldc.i4.1 + IL_00fc: sub + IL_00fd: stloc.0 + IL_00fe: ldloc.0 + IL_00ff: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0104: ldloc.0 + IL_0105: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010a: nop + IL_010b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0110: dup + IL_0111: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_0116: ldc.i4.1 + IL_0117: sub + IL_0118: stloc.0 + IL_0119: ldloc.0 + IL_011a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_011f: nop + IL_0120: ldloc.0 + IL_0121: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0126: nop + IL_0127: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_012c: dup + IL_012d: ldfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_0132: ldc.i4.1 + IL_0133: sub + IL_0134: stloc.0 + IL_0135: ldloc.0 + IL_0136: stfld uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UintField + IL_013b: ldloc.0 + IL_013c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0141: nop + IL_0142: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0147: dup + IL_0148: callvirt instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UintProp() + IL_014d: ldc.i4.1 + IL_014e: sub + IL_014f: stloc.0 + IL_0150: ldloc.0 + IL_0151: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UintProp(uint32) + IL_0156: nop + IL_0157: ldloc.0 + IL_0158: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0163: ldflda uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UintField + IL_0168: dup + IL_0169: ldind.u4 + IL_016a: ldc.i4.1 + IL_016b: sub + IL_016c: stloc.0 + IL_016d: ldloc.0 + IL_016e: stind.i4 + IL_016f: ldloc.0 + IL_0170: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0175: nop + IL_0176: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_017b: dup + IL_017c: call instance uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UintProp() + IL_0181: ldc.i4.1 + IL_0182: sub + IL_0183: stloc.0 + IL_0184: ldloc.0 + IL_0185: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UintProp(uint32) + IL_018a: nop + IL_018b: ldloc.0 + IL_018c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0191: nop + IL_0192: call uint32& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUint() + IL_0197: dup + IL_0198: ldind.u4 + IL_0199: ldc.i4.1 + IL_019a: sub + IL_019b: stloc.0 + IL_019c: ldloc.0 + IL_019d: stind.i4 + IL_019e: ldloc.0 + IL_019f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a4: nop + IL_01a5: ret + } // end of method CompoundAssignmentTest::UintPreDecTest - IL_0013: ldloc.1 - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementAndReturn + .method public hidebysig static void LongAddTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: add + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: add + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: add + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: add + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: add + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: add + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: add + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: add + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: add + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: add + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: add + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: add + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: add + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: add + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: add + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongAddTest - .method public hidebysig instance int32 - PreIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongSubtractTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) + // Code size 290 (0x122) .maxstack 3 - .locals init (int16 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldind.i2 - IL_000a: ldc.i4.1 - IL_000b: sub - IL_000c: conv.i2 - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: stind.i2 - IL_0010: ldloc.0 - IL_0011: stloc.1 - IL_0012: br.s IL_0014 + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: sub + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: sub + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: sub + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: sub + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: sub + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: sub + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: sub + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: sub + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: sub + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: sub + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: sub + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: sub + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: sub + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: sub + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongSubtractTest - IL_0014: ldloc.1 - IL_0015: ret - } // end of method CompoundAssignmentTest::PreIncrementArrayElementShort + .method public hidebysig static void LongMultiplyTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: mul + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: mul + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: mul + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: mul + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: mul + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: mul + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: mul + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: mul + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: mul + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: mul + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: mul + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: mul + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: mul + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: mul + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: mul + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: mul + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: mul + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongMultiplyTest - .method public hidebysig instance int32 - PostIncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongDivideTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) + // Code size 290 (0x122) .maxstack 3 - .locals init (int16 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldind.i2 - IL_000a: stloc.0 - IL_000b: ldloc.0 - IL_000c: ldc.i4.1 - IL_000d: add - IL_000e: conv.i2 - IL_000f: stind.i2 - IL_0010: ldloc.0 - IL_0011: stloc.1 - IL_0012: br.s IL_0014 + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: div + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: div + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: div + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: div + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: div + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: div + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: div + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: div + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: div + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: div + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: div + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: div + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: div + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: div + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: div + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: div + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: div + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongDivideTest - IL_0014: ldloc.1 - IL_0015: ret - } // end of method CompoundAssignmentTest::PostIncrementArrayElementShort + .method public hidebysig static void LongModulusTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: rem + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: rem + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: rem + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: rem + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: rem + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: rem + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: rem + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: rem + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: rem + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: rem + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: rem + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: rem + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: rem + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: rem + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: rem + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: rem + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: rem + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongModulusTest - .method public hidebysig instance void - IncrementArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongLeftShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldind.i2 - IL_000a: ldc.i4.1 - IL_000b: add - IL_000c: conv.i2 - IL_000d: stind.i2 - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementArrayElementShort + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003e: dup + IL_003f: ldind.i8 + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: stind.i8 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005e: ldc.i4.5 + IL_005f: shl + IL_0060: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0070: ldc.i4.5 + IL_0071: shl + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0082: dup + IL_0083: ldind.i8 + IL_0084: ldc.i4.5 + IL_0085: shl + IL_0086: stind.i8 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0092: ldc.i4.5 + IL_0093: shl + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ca: ldc.i4.5 + IL_00cb: shl + IL_00cc: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ee: dup + IL_00ef: ldind.i8 + IL_00f0: ldc.i4.5 + IL_00f1: shl + IL_00f2: stind.i8 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0105: nop + IL_0106: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_010b: dup + IL_010c: ldind.i8 + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: stind.i8 + IL_0110: ret + } // end of method CompoundAssignmentTest::LongLeftShiftTest - .method public hidebysig instance void - DoubleArrayElementShort(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongRightShiftTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 273 (0x111) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldind.i2 - IL_000a: ldc.i4.2 - IL_000b: mul - IL_000c: conv.i2 - IL_000d: stind.i2 - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShort + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: shr + IL_0008: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000d: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0012: ldc.i4.5 + IL_0013: shr + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0021: ldc.i4.5 + IL_0022: shr + IL_0023: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_002f: ldc.i4.5 + IL_0030: shr + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_003e: dup + IL_003f: ldind.i8 + IL_0040: ldc.i4.5 + IL_0041: shr + IL_0042: stind.i8 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_004b: ldc.i4.5 + IL_004c: shr + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_005e: ldc.i4.5 + IL_005f: shr + IL_0060: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0070: ldc.i4.5 + IL_0071: shr + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0082: dup + IL_0083: ldind.i8 + IL_0084: ldc.i4.5 + IL_0085: shr + IL_0086: stind.i8 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0092: ldc.i4.5 + IL_0093: shr + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a5: ldc.i4.5 + IL_00a6: shr + IL_00a7: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00ca: ldc.i4.5 + IL_00cb: shr + IL_00cc: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00dc: ldc.i4.5 + IL_00dd: shr + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ee: dup + IL_00ef: ldind.i8 + IL_00f0: ldc.i4.5 + IL_00f1: shr + IL_00f2: stind.i8 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00fe: ldc.i4.5 + IL_00ff: shr + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0105: nop + IL_0106: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_010b: dup + IL_010c: ldind.i8 + IL_010d: ldc.i4.5 + IL_010e: shr + IL_010f: stind.i8 + IL_0110: ret + } // end of method CompoundAssignmentTest::LongRightShiftTest - .method public hidebysig instance int16 - DoubleArrayElementShortAndReturn(int16[] 'array', - int32 pos) cil managed + .method public hidebysig static void LongBitAndTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) + // Code size 290 (0x122) .maxstack 3 - .locals init (int16 V_0, - int16 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: ldarg.2 - IL_0003: ldelema [mscorlib]System.Int16 - IL_0008: dup - IL_0009: ldind.i2 - IL_000a: ldc.i4.2 - IL_000b: mul - IL_000c: conv.i2 - IL_000d: dup - IL_000e: stloc.0 - IL_000f: stind.i2 - IL_0010: ldloc.0 - IL_0011: stloc.1 - IL_0012: br.s IL_0014 + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: and + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: and + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: and + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: and + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: and + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: and + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: and + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: and + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: and + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: and + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: and + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: and + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: and + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: and + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: and + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: and + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: and + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongBitAndTest - IL_0014: ldloc.1 - IL_0015: ret - } // end of method CompoundAssignmentTest::DoubleArrayElementShortAndReturn + .method public hidebysig static void LongBitOrTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 290 (0x122) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: or + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: or + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: or + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: or + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: or + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: or + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: or + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: or + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: or + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: or + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: or + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: or + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: or + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: or + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: or + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: or + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: or + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongBitOrTest - .method public hidebysig instance int32 - PreIncrementInstanceField() cil managed + .method public hidebysig static void LongBitXorTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: stloc.0 - IL_0010: ldloc.0 - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.0 - IL_0017: stloc.1 - IL_0018: br.s IL_001a + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: xor + IL_0009: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000e: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: xor + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: xor + IL_0026: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: xor + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: xor + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: xor + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: xor + IL_0067: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: xor + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: xor + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: xor + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: xor + IL_00b2: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: xor + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: xor + IL_00d9: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: xor + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: xor + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: xor + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0115: nop + IL_0116: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: xor + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::LongBitXorTest - IL_001a: ldloc.1 - IL_001b: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField + .method public hidebysig static void LongPostIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int64 V_0) + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: add + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: add + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: add + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: add + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: conv.i8 + IL_0068: add + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: conv.i8 + IL_007d: add + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: conv.i8 + IL_009a: add + IL_009b: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: conv.i8 + IL_00b6: add + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: add + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: conv.i8 + IL_00ec: add + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: conv.i8 + IL_0109: add + IL_010a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: add + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: add + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: conv.i8 + IL_015e: add + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: conv.i8 + IL_017c: add + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: add + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: conv.i8 + IL_01ad: add + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::LongPostIncTest - .method public hidebysig instance int32 - PostIncrementInstanceField() cil managed + .method public hidebysig static void LongPreIncTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 439 (0x1b7) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.0 - IL_0017: stloc.1 - IL_0018: br.s IL_001a + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: dup + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: add + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: add + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: add + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: ldc.i4.1 + IL_0065: conv.i8 + IL_0066: add + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0079: ldc.i4.1 + IL_007a: conv.i8 + IL_007b: add + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldc.i4.1 + IL_0097: conv.i8 + IL_0098: add + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b2: ldc.i4.1 + IL_00b3: conv.i8 + IL_00b4: add + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: ldc.i4.1 + IL_00d1: conv.i8 + IL_00d2: add + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e8: ldc.i4.1 + IL_00e9: conv.i8 + IL_00ea: add + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0105: ldc.i4.1 + IL_0106: conv.i8 + IL_0107: add + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0121: ldc.i4.1 + IL_0122: conv.i8 + IL_0123: add + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013e: ldc.i4.1 + IL_013f: conv.i8 + IL_0140: add + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: add + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: ldc.i4.1 + IL_0179: conv.i8 + IL_017a: add + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: add + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: ldc.i4.1 + IL_01aa: conv.i8 + IL_01ab: add + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::LongPreIncTest - IL_001a: ldloc.1 - IL_001b: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField + .method public hidebysig static void LongPostDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int64 V_0) + IL_0000: nop + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: sub + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: sub + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: sub + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: sub + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: conv.i8 + IL_0068: sub + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: conv.i8 + IL_007d: sub + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: conv.i8 + IL_009a: sub + IL_009b: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: conv.i8 + IL_00b6: sub + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: sub + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: conv.i8 + IL_00ec: sub + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: conv.i8 + IL_0109: sub + IL_010a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: sub + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: sub + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: conv.i8 + IL_015e: sub + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: conv.i8 + IL_017c: sub + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: sub + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: conv.i8 + IL_01ad: sub + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::LongPostDecTest - .method public hidebysig instance void - IncrementInstanceField() cil managed + .method public hidebysig static void LongPreDecTest(int64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (int64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0014: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField + IL_0001: ldsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: dup + IL_000a: stsfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::longField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: sub + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: sub + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: sub + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: ldc.i4.1 + IL_0065: conv.i8 + IL_0066: sub + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0079: ldc.i4.1 + IL_007a: conv.i8 + IL_007b: sub + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0096: ldc.i4.1 + IL_0097: conv.i8 + IL_0098: sub + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_00b2: ldc.i4.1 + IL_00b3: conv.i8 + IL_00b4: sub + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: ldc.i4.1 + IL_00d1: conv.i8 + IL_00d2: sub + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_00e8: ldc.i4.1 + IL_00e9: conv.i8 + IL_00ea: sub + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0105: ldc.i4.1 + IL_0106: conv.i8 + IL_0107: sub + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_0121: ldc.i4.1 + IL_0122: conv.i8 + IL_0123: sub + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_013e: ldc.i4.1 + IL_013f: conv.i8 + IL_0140: sub + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::LongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_LongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: sub + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_LongProp(int64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::LongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: ldc.i4.1 + IL_0179: conv.i8 + IL_017a: sub + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_LongProp() + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: sub + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_LongProp(int64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call int64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefLong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: ldc.i4.1 + IL_01aa: conv.i8 + IL_01ab: sub + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::LongPreDecTest - .method public hidebysig instance void - DoubleInstanceField() cil managed + .method public hidebysig static void UlongAddTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 8 + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0014: ret - } // end of method CompoundAssignmentTest::DoubleInstanceField + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: add + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: add + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: add + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: add + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: add + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: add + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: add + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: add + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: add + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: add + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: add + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: add + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: add + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: add + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: add + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: add + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: add + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongAddTest - .method public hidebysig instance int32 - DoubleInstanceFieldAndReturn() cil managed + .method public hidebysig static void UlongSubtractTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 28 (0x1c) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: dup - IL_0010: stloc.0 - IL_0011: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0016: ldloc.0 - IL_0017: stloc.1 - IL_0018: br.s IL_001a - - IL_001a: ldloc.1 - IL_001b: ret - } // end of method CompoundAssignmentTest::DoubleInstanceFieldAndReturn + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: sub + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: sub + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: sub + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: sub + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: sub + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: sub + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: sub + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: sub + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: sub + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: sub + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: sub + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: sub + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: sub + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: sub + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: sub + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: sub + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongSubtractTest - .method public hidebysig instance int32 - PreIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongMultiplyTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: stloc.0 - IL_000b: ldloc.0 - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0011: ldloc.0 - IL_0012: stloc.1 - IL_0013: br.s IL_0015 - - IL_0015: ldloc.1 - IL_0016: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceField2 + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: mul + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: mul + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: mul + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: mul + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: mul + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: mul + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: mul + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: mul + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: mul + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: mul + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: mul + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: mul + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: mul + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: mul + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: mul + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: mul + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: mul + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongMultiplyTest - .method public hidebysig instance int32 - PostIncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongDivideTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0008: stloc.0 - IL_0009: ldloc.0 - IL_000a: ldc.i4.1 - IL_000b: add - IL_000c: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0011: ldloc.0 - IL_0012: stloc.1 - IL_0013: br.s IL_0015 - - IL_0015: ldloc.1 - IL_0016: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceField2 + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: div.un + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: div.un + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: div.un + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: div.un + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: div.un + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: div.un + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: div.un + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: div.un + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: div.un + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: div.un + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: div.un + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: div.un + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: div.un + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: div.un + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: div.un + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: div.un + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: div.un + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongDivideTest - .method public hidebysig instance void - IncrementInstanceField2(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass m) cil managed + .method public hidebysig static void UlongModulusTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 16 (0x10) - .maxstack 8 + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.1 - IL_0002: dup - IL_0003: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_0008: ldc.i4.1 - IL_0009: add - IL_000a: stfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::Field - IL_000f: ret - } // end of method CompoundAssignmentTest::IncrementInstanceField2 + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: rem.un + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: rem.un + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: rem.un + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: rem.un + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: rem.un + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: rem.un + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: rem.un + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: rem.un + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: rem.un + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: rem.un + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: rem.un + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: rem.un + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: rem.un + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: rem.un + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: rem.un + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: rem.un + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: rem.un + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongModulusTest - .method public hidebysig instance int32 - PreIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongLeftShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 273 (0x111) .maxstack 3 - .locals init (int16 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.i2 - IL_0010: stloc.0 - IL_0011: ldloc.0 - IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0017: ldloc.0 - IL_0018: stloc.1 - IL_0019: br.s IL_001b - - IL_001b: ldloc.1 - IL_001c: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceFieldShort + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: shl + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: shl + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: shl + IL_0023: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002f: ldc.i4.5 + IL_0030: shl + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003e: dup + IL_003f: ldind.i8 + IL_0040: ldc.i4.5 + IL_0041: shl + IL_0042: stind.i8 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004b: ldc.i4.5 + IL_004c: shl + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005e: ldc.i4.5 + IL_005f: shl + IL_0060: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0070: ldc.i4.5 + IL_0071: shl + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0082: dup + IL_0083: ldind.i8 + IL_0084: ldc.i4.5 + IL_0085: shl + IL_0086: stind.i8 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0092: ldc.i4.5 + IL_0093: shl + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a5: ldc.i4.5 + IL_00a6: shl + IL_00a7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shl + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ca: ldc.i4.5 + IL_00cb: shl + IL_00cc: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00dc: ldc.i4.5 + IL_00dd: shl + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ee: dup + IL_00ef: ldind.i8 + IL_00f0: ldc.i4.5 + IL_00f1: shl + IL_00f2: stind.i8 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00fe: ldc.i4.5 + IL_00ff: shl + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0105: nop + IL_0106: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_010b: dup + IL_010c: ldind.i8 + IL_010d: ldc.i4.5 + IL_010e: shl + IL_010f: stind.i8 + IL_0110: ret + } // end of method CompoundAssignmentTest::UlongLeftShiftTest - .method public hidebysig instance int32 - PostIncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongRightShiftTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 273 (0x111) .maxstack 3 - .locals init (int16 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.i2 - IL_0012: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0017: ldloc.0 - IL_0018: stloc.1 - IL_0019: br.s IL_001b - - IL_001b: ldloc.1 - IL_001c: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceFieldShort + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: shr.un + IL_0008: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000d: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0012: ldc.i4.5 + IL_0013: shr.un + IL_0014: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0019: nop + IL_001a: ldarg.1 + IL_001b: dup + IL_001c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0021: ldc.i4.5 + IL_0022: shr.un + IL_0023: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0028: ldarg.1 + IL_0029: dup + IL_002a: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_002f: ldc.i4.5 + IL_0030: shr.un + IL_0031: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0036: nop + IL_0037: ldarga.s s + IL_0039: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_003e: dup + IL_003f: ldind.i8 + IL_0040: ldc.i4.5 + IL_0041: shr.un + IL_0042: stind.i8 + IL_0043: ldarga.s s + IL_0045: dup + IL_0046: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_004b: ldc.i4.5 + IL_004c: shr.un + IL_004d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0052: nop + IL_0053: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0058: dup + IL_0059: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_005e: ldc.i4.5 + IL_005f: shr.un + IL_0060: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0065: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_006a: dup + IL_006b: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0070: ldc.i4.5 + IL_0071: shr.un + IL_0072: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0077: nop + IL_0078: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_007d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0082: dup + IL_0083: ldind.i8 + IL_0084: ldc.i4.5 + IL_0085: shr.un + IL_0086: stind.i8 + IL_0087: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_008c: dup + IL_008d: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0092: ldc.i4.5 + IL_0093: shr.un + IL_0094: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0099: nop + IL_009a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_009f: dup + IL_00a0: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a5: ldc.i4.5 + IL_00a6: shr.un + IL_00a7: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ac: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00b1: dup + IL_00b2: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b7: ldc.i4.5 + IL_00b8: shr.un + IL_00b9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00be: nop + IL_00bf: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00c4: dup + IL_00c5: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00ca: ldc.i4.5 + IL_00cb: shr.un + IL_00cc: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d1: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d6: dup + IL_00d7: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00dc: ldc.i4.5 + IL_00dd: shr.un + IL_00de: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00e3: nop + IL_00e4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00e9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ee: dup + IL_00ef: ldind.i8 + IL_00f0: ldc.i4.5 + IL_00f1: shr.un + IL_00f2: stind.i8 + IL_00f3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f8: dup + IL_00f9: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00fe: ldc.i4.5 + IL_00ff: shr.un + IL_0100: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0105: nop + IL_0106: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_010b: dup + IL_010c: ldind.i8 + IL_010d: ldc.i4.5 + IL_010e: shr.un + IL_010f: stind.i8 + IL_0110: ret + } // end of method CompoundAssignmentTest::UlongRightShiftTest - .method public hidebysig instance void - IncrementInstanceFieldShort() cil managed + .method public hidebysig static void UlongBitAndTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 290 (0x122) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: ldfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.i2 - IL_0010: stfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::ShortField - IL_0015: ret - } // end of method CompoundAssignmentTest::IncrementInstanceFieldShort + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: and + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: and + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: and + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: and + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: and + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: and + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: and + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: and + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: and + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: and + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: and + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: and + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: and + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: and + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: and + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: and + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: and + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongBitAndTest - .method public hidebysig instance int32 - PreIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongBitOrTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: stloc.0 - IL_0010: ldloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.0 - IL_0018: stloc.1 - IL_0019: br.s IL_001b - - IL_001b: ldloc.1 - IL_001c: ret - } // end of method CompoundAssignmentTest::PreIncrementInstanceProperty + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: or + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: or + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: or + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: or + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: or + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: or + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: or + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: or + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: or + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: or + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: or + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: or + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: or + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: or + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: or + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: or + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: or + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongBitOrTest - .method public hidebysig instance int32 - PostIncrementInstanceProperty() cil managed + .method public hidebysig static void UlongBitXorTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 290 (0x122) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.0 - IL_0018: stloc.1 - IL_0019: br.s IL_001b + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.5 + IL_0007: conv.i8 + IL_0008: xor + IL_0009: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000e: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_0013: ldc.i4.5 + IL_0014: conv.i8 + IL_0015: xor + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_001b: nop + IL_001c: ldarg.1 + IL_001d: dup + IL_001e: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0023: ldc.i4.5 + IL_0024: conv.i8 + IL_0025: xor + IL_0026: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_002b: ldarg.1 + IL_002c: dup + IL_002d: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0032: ldc.i4.5 + IL_0033: conv.i8 + IL_0034: xor + IL_0035: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_003a: nop + IL_003b: ldarga.s s + IL_003d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0042: dup + IL_0043: ldind.i8 + IL_0044: ldc.i4.5 + IL_0045: conv.i8 + IL_0046: xor + IL_0047: stind.i8 + IL_0048: ldarga.s s + IL_004a: dup + IL_004b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0050: ldc.i4.5 + IL_0051: conv.i8 + IL_0052: xor + IL_0053: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0058: nop + IL_0059: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_005e: dup + IL_005f: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0064: ldc.i4.5 + IL_0065: conv.i8 + IL_0066: xor + IL_0067: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_006c: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0071: dup + IL_0072: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0077: ldc.i4.5 + IL_0078: conv.i8 + IL_0079: xor + IL_007a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_007f: nop + IL_0080: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0085: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_008a: dup + IL_008b: ldind.i8 + IL_008c: ldc.i4.5 + IL_008d: conv.i8 + IL_008e: xor + IL_008f: stind.i8 + IL_0090: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0095: dup + IL_0096: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_009b: ldc.i4.5 + IL_009c: conv.i8 + IL_009d: xor + IL_009e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00a3: nop + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00a9: dup + IL_00aa: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00af: ldc.i4.5 + IL_00b0: conv.i8 + IL_00b1: xor + IL_00b2: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00bc: dup + IL_00bd: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00c2: ldc.i4.5 + IL_00c3: conv.i8 + IL_00c4: xor + IL_00c5: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00ca: nop + IL_00cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00d0: dup + IL_00d1: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00d6: ldc.i4.5 + IL_00d7: conv.i8 + IL_00d8: xor + IL_00d9: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00de: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00e3: dup + IL_00e4: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00e9: ldc.i4.5 + IL_00ea: conv.i8 + IL_00eb: xor + IL_00ec: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00f1: nop + IL_00f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_00f7: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00fc: dup + IL_00fd: ldind.i8 + IL_00fe: ldc.i4.5 + IL_00ff: conv.i8 + IL_0100: xor + IL_0101: stind.i8 + IL_0102: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0107: dup + IL_0108: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_010d: ldc.i4.5 + IL_010e: conv.i8 + IL_010f: xor + IL_0110: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0115: nop + IL_0116: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_011b: dup + IL_011c: ldind.i8 + IL_011d: ldc.i4.5 + IL_011e: conv.i8 + IL_011f: xor + IL_0120: stind.i8 + IL_0121: ret + } // end of method CompoundAssignmentTest::UlongBitXorTest - IL_001b: ldloc.1 - IL_001c: ret - } // end of method CompoundAssignmentTest::PostIncrementInstanceProperty + .method public hidebysig static void UlongPostIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint64 V_0) + IL_0000: nop + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: add + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: add + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: add + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: add + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: conv.i8 + IL_0068: add + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: conv.i8 + IL_007d: add + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: conv.i8 + IL_009a: add + IL_009b: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: conv.i8 + IL_00b6: add + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: add + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: conv.i8 + IL_00ec: add + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: conv.i8 + IL_0109: add + IL_010a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: add + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: add + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: conv.i8 + IL_015e: add + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: conv.i8 + IL_017c: add + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: add + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: conv.i8 + IL_01ad: add + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UlongPostIncTest - .method public hidebysig instance void - IncrementInstanceProperty() cil managed + .method public hidebysig static void UlongPreIncTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 24 (0x18) + // Code size 439 (0x1b7) .maxstack 3 - .locals init (int32 V_0) + .locals init (uint64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ret - } // end of method CompoundAssignmentTest::IncrementInstanceProperty + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: add + IL_0009: dup + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: add + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: add + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: add + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: ldc.i4.1 + IL_0065: conv.i8 + IL_0066: add + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0079: ldc.i4.1 + IL_007a: conv.i8 + IL_007b: add + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldc.i4.1 + IL_0097: conv.i8 + IL_0098: add + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b2: ldc.i4.1 + IL_00b3: conv.i8 + IL_00b4: add + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: ldc.i4.1 + IL_00d1: conv.i8 + IL_00d2: add + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e8: ldc.i4.1 + IL_00e9: conv.i8 + IL_00ea: add + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0105: ldc.i4.1 + IL_0106: conv.i8 + IL_0107: add + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0121: ldc.i4.1 + IL_0122: conv.i8 + IL_0123: add + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013e: ldc.i4.1 + IL_013f: conv.i8 + IL_0140: add + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: add + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: ldc.i4.1 + IL_0179: conv.i8 + IL_017a: add + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: add + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: ldc.i4.1 + IL_01aa: conv.i8 + IL_01ab: add + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UlongPreIncTest - .method public hidebysig instance void - DoubleInstanceProperty() cil managed + .method public hidebysig static void UlongPostDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 22 (0x16) - .maxstack 8 + // Code size 439 (0x1b7) + .maxstack 3 + .locals init (uint64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: dup + IL_0007: ldc.i4.1 + IL_0008: conv.i8 + IL_0009: sub + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) IL_0014: nop - IL_0015: ret - } // end of method CompoundAssignmentTest::DoubleInstanceProperty + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: dup + IL_001b: ldc.i4.1 + IL_001c: conv.i8 + IL_001d: sub + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: stloc.0 + IL_0032: ldloc.0 + IL_0033: ldc.i4.1 + IL_0034: conv.i8 + IL_0035: sub + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: stloc.0 + IL_004a: ldloc.0 + IL_004b: ldc.i4.1 + IL_004c: conv.i8 + IL_004d: sub + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: stloc.0 + IL_0065: ldloc.0 + IL_0066: ldc.i4.1 + IL_0067: conv.i8 + IL_0068: sub + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0079: stloc.0 + IL_007a: ldloc.0 + IL_007b: ldc.i4.1 + IL_007c: conv.i8 + IL_007d: sub + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: stloc.0 + IL_0097: ldloc.0 + IL_0098: ldc.i4.1 + IL_0099: conv.i8 + IL_009a: sub + IL_009b: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b2: stloc.0 + IL_00b3: ldloc.0 + IL_00b4: ldc.i4.1 + IL_00b5: conv.i8 + IL_00b6: sub + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: stloc.0 + IL_00d1: ldloc.0 + IL_00d2: ldc.i4.1 + IL_00d3: conv.i8 + IL_00d4: sub + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e8: stloc.0 + IL_00e9: ldloc.0 + IL_00ea: ldc.i4.1 + IL_00eb: conv.i8 + IL_00ec: sub + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0105: stloc.0 + IL_0106: ldloc.0 + IL_0107: ldc.i4.1 + IL_0108: conv.i8 + IL_0109: sub + IL_010a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0121: stloc.0 + IL_0122: ldloc.0 + IL_0123: ldc.i4.1 + IL_0124: conv.i8 + IL_0125: sub + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013e: stloc.0 + IL_013f: ldloc.0 + IL_0140: ldc.i4.1 + IL_0141: conv.i8 + IL_0142: sub + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: stloc.0 + IL_015b: ldloc.0 + IL_015c: ldc.i4.1 + IL_015d: conv.i8 + IL_015e: sub + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: stloc.0 + IL_0179: ldloc.0 + IL_017a: ldc.i4.1 + IL_017b: conv.i8 + IL_017c: sub + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0190: stloc.0 + IL_0191: ldloc.0 + IL_0192: ldc.i4.1 + IL_0193: conv.i8 + IL_0194: sub + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: stloc.0 + IL_01aa: ldloc.0 + IL_01ab: ldc.i4.1 + IL_01ac: conv.i8 + IL_01ad: sub + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UlongPostDecTest - .method public hidebysig instance int32 - DoubleInstancePropertyAndReturn() cil managed + .method public hidebysig static void UlongPreDecTest(uint64 p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 29 (0x1d) + // Code size 439 (0x1b7) .maxstack 3 - .locals init (int32 V_0, - int32 V_1) + .locals init (uint64 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_Property() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: dup - IL_0010: stloc.0 - IL_0011: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_Property(int32) - IL_0016: nop - IL_0017: ldloc.0 - IL_0018: stloc.1 - IL_0019: br.s IL_001b - - IL_001b: ldloc.1 - IL_001c: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyAndReturn + IL_0001: ldsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_0006: ldc.i4.1 + IL_0007: conv.i8 + IL_0008: sub + IL_0009: dup + IL_000a: stsfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ulongField + IL_000f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0014: nop + IL_0015: call uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + IL_001a: ldc.i4.1 + IL_001b: conv.i8 + IL_001c: sub + IL_001d: dup + IL_001e: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + IL_0023: nop + IL_0024: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0029: nop + IL_002a: ldarg.1 + IL_002b: dup + IL_002c: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0031: ldc.i4.1 + IL_0032: conv.i8 + IL_0033: sub + IL_0034: stloc.0 + IL_0035: ldloc.0 + IL_0036: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_003b: ldloc.0 + IL_003c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0041: nop + IL_0042: ldarg.1 + IL_0043: dup + IL_0044: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0049: ldc.i4.1 + IL_004a: conv.i8 + IL_004b: sub + IL_004c: stloc.0 + IL_004d: ldloc.0 + IL_004e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0053: nop + IL_0054: ldloc.0 + IL_0055: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_005a: nop + IL_005b: ldarga.s s + IL_005d: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0062: dup + IL_0063: ldind.i8 + IL_0064: ldc.i4.1 + IL_0065: conv.i8 + IL_0066: sub + IL_0067: stloc.0 + IL_0068: ldloc.0 + IL_0069: stind.i8 + IL_006a: ldloc.0 + IL_006b: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0070: nop + IL_0071: ldarga.s s + IL_0073: dup + IL_0074: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0079: ldc.i4.1 + IL_007a: conv.i8 + IL_007b: sub + IL_007c: stloc.0 + IL_007d: ldloc.0 + IL_007e: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_0083: nop + IL_0084: ldloc.0 + IL_0085: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_008a: nop + IL_008b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0090: dup + IL_0091: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0096: ldc.i4.1 + IL_0097: conv.i8 + IL_0098: sub + IL_0099: stloc.0 + IL_009a: ldloc.0 + IL_009b: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_00a0: ldloc.0 + IL_00a1: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00a6: nop + IL_00a7: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ac: dup + IL_00ad: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_00b2: ldc.i4.1 + IL_00b3: conv.i8 + IL_00b4: sub + IL_00b5: stloc.0 + IL_00b6: ldloc.0 + IL_00b7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_00bc: nop + IL_00bd: ldloc.0 + IL_00be: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00c3: nop + IL_00c4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c9: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_00ce: dup + IL_00cf: ldind.i8 + IL_00d0: ldc.i4.1 + IL_00d1: conv.i8 + IL_00d2: sub + IL_00d3: stloc.0 + IL_00d4: ldloc.0 + IL_00d5: stind.i8 + IL_00d6: ldloc.0 + IL_00d7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00dc: nop + IL_00dd: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e2: dup + IL_00e3: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_00e8: ldc.i4.1 + IL_00e9: conv.i8 + IL_00ea: sub + IL_00eb: stloc.0 + IL_00ec: ldloc.0 + IL_00ed: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_00f2: nop + IL_00f3: ldloc.0 + IL_00f4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00f9: nop + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ff: dup + IL_0100: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0105: ldc.i4.1 + IL_0106: conv.i8 + IL_0107: sub + IL_0108: stloc.0 + IL_0109: ldloc.0 + IL_010a: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_010f: ldloc.0 + IL_0110: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0115: nop + IL_0116: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_011b: dup + IL_011c: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_0121: ldc.i4.1 + IL_0122: conv.i8 + IL_0123: sub + IL_0124: stloc.0 + IL_0125: ldloc.0 + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_012b: nop + IL_012c: ldloc.0 + IL_012d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0132: nop + IL_0133: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0138: dup + IL_0139: ldfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_013e: ldc.i4.1 + IL_013f: conv.i8 + IL_0140: sub + IL_0141: stloc.0 + IL_0142: ldloc.0 + IL_0143: stfld uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::UlongField + IL_0148: ldloc.0 + IL_0149: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014e: nop + IL_014f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0154: dup + IL_0155: callvirt instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_UlongProp() + IL_015a: ldc.i4.1 + IL_015b: conv.i8 + IL_015c: sub + IL_015d: stloc.0 + IL_015e: ldloc.0 + IL_015f: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_UlongProp(uint64) + IL_0164: nop + IL_0165: ldloc.0 + IL_0166: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_016b: nop + IL_016c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0171: ldflda uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::UlongField + IL_0176: dup + IL_0177: ldind.i8 + IL_0178: ldc.i4.1 + IL_0179: conv.i8 + IL_017a: sub + IL_017b: stloc.0 + IL_017c: ldloc.0 + IL_017d: stind.i8 + IL_017e: ldloc.0 + IL_017f: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0184: nop + IL_0185: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018a: dup + IL_018b: call instance uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_UlongProp() + IL_0190: ldc.i4.1 + IL_0191: conv.i8 + IL_0192: sub + IL_0193: stloc.0 + IL_0194: ldloc.0 + IL_0195: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_UlongProp(uint64) + IL_019a: nop + IL_019b: ldloc.0 + IL_019c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a1: nop + IL_01a2: call uint64& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefUlong() + IL_01a7: dup + IL_01a8: ldind.i8 + IL_01a9: ldc.i4.1 + IL_01aa: conv.i8 + IL_01ab: sub + IL_01ac: stloc.0 + IL_01ad: ldloc.0 + IL_01ae: stind.i8 + IL_01af: ldloc.0 + IL_01b0: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01b5: nop + IL_01b6: ret + } // end of method CompoundAssignmentTest::UlongPreDecTest - .method public hidebysig instance int32 - PreIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassAddTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 341 (0x155) .maxstack 3 - .locals init (uint8 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.1 - IL_000e: add - IL_000f: conv.u1 - IL_0010: stloc.0 - IL_0011: ldloc.0 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.0 - IL_0019: stloc.1 - IL_001a: br.s IL_001c - - IL_001c: ldloc.1 - IL_001d: ret - } // end of method CompoundAssignmentTest::PreIncrementInstancePropertyByte + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassAddTest - .method public hidebysig instance int32 - PostIncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassSubtractTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 341 (0x155) .maxstack 3 - .locals init (uint8 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.u1 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.0 - IL_0019: stloc.1 - IL_001a: br.s IL_001c - - IL_001c: ldloc.1 - IL_001d: ret - } // end of method CompoundAssignmentTest::PostIncrementInstancePropertyByte + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Subtraction(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassSubtractTest - .method public hidebysig instance void - IncrementInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassMultiplyTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 25 (0x19) + // Code size 341 (0x155) .maxstack 3 - .locals init (uint8 V_0) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: stloc.0 - IL_000e: ldloc.0 - IL_000f: ldc.i4.1 - IL_0010: add - IL_0011: conv.u1 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ret - } // end of method CompoundAssignmentTest::IncrementInstancePropertyByte + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Multiply(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassMultiplyTest - .method public hidebysig instance void - DoubleInstancePropertyByte() cil managed + .method public hidebysig static void CustomClassDivideTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 23 (0x17) - .maxstack 8 + // Code size 341 (0x155) + .maxstack 3 IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.u1 - IL_0010: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0015: nop - IL_0016: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByte + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Division(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassDivideTest - .method public hidebysig instance int32 - DoubleInstancePropertyByteAndReturn() cil managed + .method public hidebysig static void CustomClassModulusTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 30 (0x1e) + // Code size 341 (0x155) .maxstack 3 - .locals init (uint8 V_0, - int32 V_1) IL_0000: nop - IL_0001: ldarg.0 - IL_0002: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::M() - IL_0007: dup - IL_0008: callvirt instance uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::get_ByteProperty() - IL_000d: ldc.i4.2 - IL_000e: mul - IL_000f: conv.u1 - IL_0010: dup - IL_0011: stloc.0 - IL_0012: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/MutableClass::set_ByteProperty(uint8) - IL_0017: nop - IL_0018: ldloc.0 - IL_0019: stloc.1 - IL_001a: br.s IL_001c - - IL_001c: ldloc.1 - IL_001d: ret - } // end of method CompoundAssignmentTest::DoubleInstancePropertyByteAndReturn + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Modulus(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassModulusTest - .method public hidebysig instance int32 - PreIncrementStaticField() cil managed + .method public hidebysig static void CustomClassLeftShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) - .maxstack 2 - .locals init (int32 V_0) + // Code size 341 (0x155) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: dup - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldc.i4.5 + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldc.i4.5 + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldc.i4.5 + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldc.i4.5 + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldc.i4.5 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldc.i4.5 + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldc.i4.5 + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldc.i4.5 + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldc.i4.5 + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldc.i4.5 + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldc.i4.5 + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldc.i4.5 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldc.i4.5 + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldc.i4.5 + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldc.i4.5 + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldc.i4.5 + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldc.i4.5 + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_LeftShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassLeftShiftTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticField + .method public hidebysig static void CustomClassRightShiftTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 341 (0x155) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldc.i4.5 + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldc.i4.5 + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldc.i4.5 + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldc.i4.5 + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldc.i4.5 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldc.i4.5 + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldc.i4.5 + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldc.i4.5 + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldc.i4.5 + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldc.i4.5 + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldc.i4.5 + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldc.i4.5 + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldc.i4.5 + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldc.i4.5 + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldc.i4.5 + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldc.i4.5 + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldc.i4.5 + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_RightShift(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassRightShiftTest - .method public hidebysig instance int32 - PostIncrementStaticField() cil managed + .method public hidebysig static void CustomClassBitAndTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) + // Code size 341 (0x155) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseAnd(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassBitAndTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticField + .method public hidebysig static void CustomClassBitOrTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 341 (0x155) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_BitwiseOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassBitOrTest - .method public hidebysig instance void - IncrementStaticField() cil managed + .method public hidebysig static void CustomClassBitXorTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 341 (0x155) + .maxstack 3 IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::IncrementStaticField + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: ldnull + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0016: ldnull + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0029: ldnull + IL_002a: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_002f: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_003b: ldnull + IL_003c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_004e: dup + IL_004f: ldind.ref + IL_0050: ldnull + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: stind.ref + IL_0057: ldarga.s s + IL_0059: dup + IL_005a: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_005f: ldnull + IL_0060: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0065: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_006a: nop + IL_006b: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0070: dup + IL_0071: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0076: ldnull + IL_0077: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_007c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0081: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0086: dup + IL_0087: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_008c: ldnull + IL_008d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0092: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0097: nop + IL_0098: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_009d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00a2: dup + IL_00a3: ldind.ref + IL_00a4: ldnull + IL_00a5: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00aa: stind.ref + IL_00ab: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00b0: dup + IL_00b1: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00b6: ldnull + IL_00b7: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00bc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c1: nop + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00c7: dup + IL_00c8: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00cd: ldnull + IL_00ce: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00d3: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00d8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00dd: dup + IL_00de: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00e3: ldnull + IL_00e4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ee: nop + IL_00ef: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_00f4: dup + IL_00f5: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00fa: ldnull + IL_00fb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0100: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0105: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_010a: dup + IL_010b: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0110: ldnull + IL_0111: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0116: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011b: nop + IL_011c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0121: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0126: dup + IL_0127: ldind.ref + IL_0128: ldnull + IL_0129: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_012e: stind.ref + IL_012f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0134: dup + IL_0135: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_013a: ldnull + IL_013b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0140: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0145: nop + IL_0146: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_014b: dup + IL_014c: ldind.ref + IL_014d: ldnull + IL_014e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_ExclusiveOr(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0153: stind.ref + IL_0154: ret + } // end of method CompoundAssignmentTest::CustomClassBitXorTest - .method public hidebysig instance void - DoubleStaticField() cil managed + .method public hidebysig static void CustomClassPostIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 14 (0xe) - .maxstack 8 + // Code size 473 (0x1d9) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000d: ret - } // end of method CompoundAssignmentTest::DoubleStaticField + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: dup + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: dup + IL_001d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: stloc.0 + IL_0036: ldloc.0 + IL_0037: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006a: dup + IL_006b: ldind.ref + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0073: stind.ref + IL_0074: ldloc.0 + IL_0075: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007a: nop + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0083: stloc.0 + IL_0084: ldloc.0 + IL_0085: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008f: nop + IL_0090: ldloc.0 + IL_0091: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0096: nop + IL_0097: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009c: dup + IL_009d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00ae: ldloc.0 + IL_00af: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b4: nop + IL_00b5: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ba: dup + IL_00bb: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c0: stloc.0 + IL_00c1: ldloc.0 + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cc: nop + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00de: dup + IL_00df: ldind.ref + IL_00e0: stloc.0 + IL_00e1: ldloc.0 + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e7: stind.ref + IL_00e8: ldloc.0 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: nop + IL_00ef: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f4: dup + IL_00f5: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00fa: stloc.0 + IL_00fb: ldloc.0 + IL_00fc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0101: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: nop + IL_0107: ldloc.0 + IL_0108: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010d: nop + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0119: stloc.0 + IL_011a: ldloc.0 + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0120: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: nop + IL_012c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0131: dup + IL_0132: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0137: stloc.0 + IL_0138: ldloc.0 + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: nop + IL_0144: ldloc.0 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: nop + IL_014b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0150: dup + IL_0151: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.0 + IL_0163: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0168: nop + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: stloc.0 + IL_0175: ldloc.0 + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0180: nop + IL_0181: ldloc.0 + IL_0182: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0187: nop + IL_0188: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0192: dup + IL_0193: ldind.ref + IL_0194: stloc.0 + IL_0195: ldloc.0 + IL_0196: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019b: stind.ref + IL_019c: ldloc.0 + IL_019d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a2: nop + IL_01a3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a8: dup + IL_01a9: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_01ae: stloc.0 + IL_01af: ldloc.0 + IL_01b0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ba: nop + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: nop + IL_01c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01c7: dup + IL_01c8: ldind.ref + IL_01c9: stloc.0 + IL_01ca: ldloc.0 + IL_01cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01d0: stind.ref + IL_01d1: ldloc.0 + IL_01d2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d7: nop + IL_01d8: ret + } // end of method CompoundAssignmentTest::CustomClassPostIncTest - .method public hidebysig instance int32 - DoubleStaticFieldAndReturn() cil managed + .method public hidebysig static void CustomClassPreIncTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 19 (0x13) + // Code size 473 (0x1d9) .maxstack 2 - .locals init (int32 V_0) + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: dup - IL_0009: stsfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticField - IL_000e: stloc.0 - IL_000f: br.s IL_0011 + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: dup + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003a: stloc.0 + IL_003b: ldloc.0 + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0054: stloc.0 + IL_0055: ldloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006a: dup + IL_006b: ldind.ref + IL_006c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: stind.ref + IL_0074: ldloc.0 + IL_0075: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007a: nop + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0083: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008f: nop + IL_0090: ldloc.0 + IL_0091: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0096: nop + IL_0097: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009c: dup + IL_009d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00ae: ldloc.0 + IL_00af: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b4: nop + IL_00b5: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ba: dup + IL_00bb: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c5: stloc.0 + IL_00c6: ldloc.0 + IL_00c7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cc: nop + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00de: dup + IL_00df: ldind.ref + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e5: stloc.0 + IL_00e6: ldloc.0 + IL_00e7: stind.ref + IL_00e8: ldloc.0 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: nop + IL_00ef: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f4: dup + IL_00f5: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stloc.0 + IL_0100: ldloc.0 + IL_0101: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: nop + IL_0107: ldloc.0 + IL_0108: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010d: nop + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0119: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011e: stloc.0 + IL_011f: ldloc.0 + IL_0120: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: nop + IL_012c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0131: dup + IL_0132: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013c: stloc.0 + IL_013d: ldloc.0 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: nop + IL_0144: ldloc.0 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: nop + IL_014b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0150: dup + IL_0151: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015b: stloc.0 + IL_015c: ldloc.0 + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.0 + IL_0163: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0168: nop + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0180: nop + IL_0181: ldloc.0 + IL_0182: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0187: nop + IL_0188: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0192: dup + IL_0193: ldind.ref + IL_0194: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: stind.ref + IL_019c: ldloc.0 + IL_019d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a2: nop + IL_01a3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a8: dup + IL_01a9: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_01ae: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b3: stloc.0 + IL_01b4: ldloc.0 + IL_01b5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ba: nop + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: nop + IL_01c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01c7: dup + IL_01c8: ldind.ref + IL_01c9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Increment(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ce: stloc.0 + IL_01cf: ldloc.0 + IL_01d0: stind.ref + IL_01d1: ldloc.0 + IL_01d2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d7: nop + IL_01d8: ret + } // end of method CompoundAssignmentTest::CustomClassPreIncTest - IL_0011: ldloc.0 - IL_0012: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturn + .method public hidebysig static void CustomClassPostDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 473 (0x1d9) + .maxstack 2 + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) + IL_0000: nop + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: dup + IL_0007: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: dup + IL_001d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: stloc.0 + IL_0036: ldloc.0 + IL_0037: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006a: dup + IL_006b: ldind.ref + IL_006c: stloc.0 + IL_006d: ldloc.0 + IL_006e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0073: stind.ref + IL_0074: ldloc.0 + IL_0075: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007a: nop + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0083: stloc.0 + IL_0084: ldloc.0 + IL_0085: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008f: nop + IL_0090: ldloc.0 + IL_0091: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0096: nop + IL_0097: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009c: dup + IL_009d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a2: stloc.0 + IL_00a3: ldloc.0 + IL_00a4: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00ae: ldloc.0 + IL_00af: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b4: nop + IL_00b5: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ba: dup + IL_00bb: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c0: stloc.0 + IL_00c1: ldloc.0 + IL_00c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cc: nop + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00de: dup + IL_00df: ldind.ref + IL_00e0: stloc.0 + IL_00e1: ldloc.0 + IL_00e2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e7: stind.ref + IL_00e8: ldloc.0 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: nop + IL_00ef: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f4: dup + IL_00f5: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00fa: stloc.0 + IL_00fb: ldloc.0 + IL_00fc: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0101: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: nop + IL_0107: ldloc.0 + IL_0108: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010d: nop + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0119: stloc.0 + IL_011a: ldloc.0 + IL_011b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0120: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: nop + IL_012c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0131: dup + IL_0132: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0137: stloc.0 + IL_0138: ldloc.0 + IL_0139: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: nop + IL_0144: ldloc.0 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: nop + IL_014b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0150: dup + IL_0151: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0156: stloc.0 + IL_0157: ldloc.0 + IL_0158: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.0 + IL_0163: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0168: nop + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: stloc.0 + IL_0175: ldloc.0 + IL_0176: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_017b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0180: nop + IL_0181: ldloc.0 + IL_0182: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0187: nop + IL_0188: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0192: dup + IL_0193: ldind.ref + IL_0194: stloc.0 + IL_0195: ldloc.0 + IL_0196: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_019b: stind.ref + IL_019c: ldloc.0 + IL_019d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a2: nop + IL_01a3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a8: dup + IL_01a9: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_01ae: stloc.0 + IL_01af: ldloc.0 + IL_01b0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ba: nop + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: nop + IL_01c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01c7: dup + IL_01c8: ldind.ref + IL_01c9: stloc.0 + IL_01ca: ldloc.0 + IL_01cb: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01d0: stind.ref + IL_01d1: ldloc.0 + IL_01d2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d7: nop + IL_01d8: ret + } // end of method CompoundAssignmentTest::CustomClassPostDecTest - .method public hidebysig instance int32 - PreIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomClassPreDecTest(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 473 (0x1d9) .maxstack 2 - .locals init (int32 V_0) + .locals init (class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: dup - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 - - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticFieldShort + IL_0001: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0006: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_000b: dup + IL_000c: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_001c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0035: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_003a: stloc.0 + IL_003b: ldloc.0 + IL_003c: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_004f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0054: stloc.0 + IL_0055: ldloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_006a: dup + IL_006b: ldind.ref + IL_006c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0071: stloc.0 + IL_0072: ldloc.0 + IL_0073: stind.ref + IL_0074: ldloc.0 + IL_0075: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_007a: nop + IL_007b: ldarga.s s + IL_007d: dup + IL_007e: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_0083: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0088: stloc.0 + IL_0089: ldloc.0 + IL_008a: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_008f: nop + IL_0090: ldloc.0 + IL_0091: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0096: nop + IL_0097: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_009c: dup + IL_009d: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00a2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00a7: stloc.0 + IL_00a8: ldloc.0 + IL_00a9: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_00ae: ldloc.0 + IL_00af: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00b4: nop + IL_00b5: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00ba: dup + IL_00bb: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_00c0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00c5: stloc.0 + IL_00c6: ldloc.0 + IL_00c7: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00cc: nop + IL_00cd: ldloc.0 + IL_00ce: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00d3: nop + IL_00d4: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00d9: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_00de: dup + IL_00df: ldind.ref + IL_00e0: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00e5: stloc.0 + IL_00e6: ldloc.0 + IL_00e7: stind.ref + IL_00e8: ldloc.0 + IL_00e9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00ee: nop + IL_00ef: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00f4: dup + IL_00f5: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_00fa: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_00ff: stloc.0 + IL_0100: ldloc.0 + IL_0101: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0106: nop + IL_0107: ldloc.0 + IL_0108: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_010d: nop + IL_010e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0113: dup + IL_0114: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0119: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_011e: stloc.0 + IL_011f: ldloc.0 + IL_0120: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0125: ldloc.0 + IL_0126: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_012b: nop + IL_012c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0131: dup + IL_0132: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0137: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_013c: stloc.0 + IL_013d: ldloc.0 + IL_013e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0143: nop + IL_0144: ldloc.0 + IL_0145: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_014a: nop + IL_014b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0150: dup + IL_0151: ldfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0156: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_015b: stloc.0 + IL_015c: ldloc.0 + IL_015d: stfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomClassField + IL_0162: ldloc.0 + IL_0163: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0168: nop + IL_0169: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_016e: dup + IL_016f: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0174: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0179: stloc.0 + IL_017a: ldloc.0 + IL_017b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0180: nop + IL_0181: ldloc.0 + IL_0182: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0187: nop + IL_0188: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_018d: ldflda class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomClassField + IL_0192: dup + IL_0193: ldind.ref + IL_0194: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_0199: stloc.0 + IL_019a: ldloc.0 + IL_019b: stind.ref + IL_019c: ldloc.0 + IL_019d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01a2: nop + IL_01a3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a8: dup + IL_01a9: call instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomClassProp() + IL_01ae: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01b3: stloc.0 + IL_01b4: ldloc.0 + IL_01b5: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ba: nop + IL_01bb: ldloc.0 + IL_01bc: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01c1: nop + IL_01c2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomClass() + IL_01c7: dup + IL_01c8: ldind.ref + IL_01c9: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Decrement(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_01ce: stloc.0 + IL_01cf: ldloc.0 + IL_01d0: stind.ref + IL_01d1: ldloc.0 + IL_01d2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d7: nop + IL_01d8: ret + } // end of method CompoundAssignmentTest::CustomClassPreDecTest - .method public hidebysig instance int32 - PostIncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructAddTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 509 (0x1fd) .maxstack 3 - .locals init (int32 V_0) + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: conv.i2 - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 - - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticFieldShort + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Addition(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructAddTest - .method public hidebysig instance void - IncrementStaticFieldShort() cil managed + .method public hidebysig static void CustomStructSubtractTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementStaticFieldShort + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Subtraction(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructSubtractTest - .method public hidebysig instance void - DoubleStaticFieldShort() cil managed + .method public hidebysig static void CustomStructMultiplyTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: conv.i2 - IL_0009: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldShort + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Multiply(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructMultiplyTest - .method public hidebysig instance int16 - DoubleStaticFieldAndReturnShort() cil managed + .method public hidebysig static void CustomStructDivideTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int16 V_0) + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: ldsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: conv.i2 - IL_0009: dup - IL_000a: stsfld int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::StaticShortField - IL_000f: stloc.0 - IL_0010: br.s IL_0012 - - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleStaticFieldAndReturnShort + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Division(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructDivideTest - .method public hidebysig instance int32 - PreIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructModulusTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) - .maxstack 2 - .locals init (int32 V_0) + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Modulus(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructModulusTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticProperty + .method public hidebysig static void CustomStructLeftShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 373 (0x175) + .maxstack 3 + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldc.i4.5 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0016: ldc.i4.5 + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0029: ldc.i4.5 + IL_002a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_003b: ldc.i4.5 + IL_003c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004e: dup + IL_004f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0054: ldc.i4.5 + IL_0055: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_005a: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005f: ldarga.s s + IL_0061: dup + IL_0062: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0067: ldc.i4.5 + IL_0068: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_006d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0072: nop + IL_0073: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0078: dup + IL_0079: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_007e: ldc.i4.5 + IL_007f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0084: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0089: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008e: dup + IL_008f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0094: ldc.i4.5 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_009a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: nop + IL_00a0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00aa: dup + IL_00ab: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b0: ldc.i4.5 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00b6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00bb: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c0: dup + IL_00c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00c6: ldc.i4.5 + IL_00c7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00cc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d1: nop + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00dd: ldc.i4.5 + IL_00de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00e3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ed: dup + IL_00ee: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00f3: ldc.i4.5 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00f9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: nop + IL_00ff: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0104: dup + IL_0105: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010a: ldc.i4.5 + IL_010b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0110: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_011a: dup + IL_011b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0120: ldc.i4.5 + IL_0121: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_012b: nop + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0131: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0136: dup + IL_0137: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_013c: ldc.i4.5 + IL_013d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0142: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0147: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014c: dup + IL_014d: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0152: ldc.i4.5 + IL_0153: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0158: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_0163: dup + IL_0164: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldc.i4.5 + IL_016a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_LeftShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_016f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0174: ret + } // end of method CompoundAssignmentTest::CustomStructLeftShiftTest - .method public hidebysig instance int32 - PostIncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructRightShiftTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 373 (0x175) .maxstack 3 - .locals init (int32 V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldc.i4.5 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_0016: ldc.i4.5 + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_001c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: nop + IL_0022: ldarg.1 + IL_0023: dup + IL_0024: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0029: ldc.i4.5 + IL_002a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_002f: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0034: ldarg.1 + IL_0035: dup + IL_0036: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_003b: ldc.i4.5 + IL_003c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0041: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0046: nop + IL_0047: ldarga.s s + IL_0049: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_004e: dup + IL_004f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0054: ldc.i4.5 + IL_0055: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_005a: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005f: ldarga.s s + IL_0061: dup + IL_0062: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0067: ldc.i4.5 + IL_0068: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_006d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0072: nop + IL_0073: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_0078: dup + IL_0079: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_007e: ldc.i4.5 + IL_007f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0084: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0089: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_008e: dup + IL_008f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0094: ldc.i4.5 + IL_0095: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_009a: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009f: nop + IL_00a0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00a5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00aa: dup + IL_00ab: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b0: ldc.i4.5 + IL_00b1: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00b6: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00bb: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00c0: dup + IL_00c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_00c6: ldc.i4.5 + IL_00c7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00cc: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d1: nop + IL_00d2: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00d7: dup + IL_00d8: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00dd: ldc.i4.5 + IL_00de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00e3: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00e8: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_00ed: dup + IL_00ee: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00f3: ldc.i4.5 + IL_00f4: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_00f9: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: nop + IL_00ff: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0104: dup + IL_0105: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_010a: ldc.i4.5 + IL_010b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0110: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0115: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_011a: dup + IL_011b: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0120: ldc.i4.5 + IL_0121: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0126: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_012b: nop + IL_012c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_0131: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_0136: dup + IL_0137: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_013c: ldc.i4.5 + IL_013d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0142: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0147: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_014c: dup + IL_014d: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_0152: ldc.i4.5 + IL_0153: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_0158: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015d: nop + IL_015e: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_0163: dup + IL_0164: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0169: ldc.i4.5 + IL_016a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_RightShift(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + int32) + IL_016f: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0174: ret + } // end of method CompoundAssignmentTest::CustomStructRightShiftTest - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticProperty + .method public hidebysig static void CustomStructBitAndTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseAnd(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructBitAndTest - .method public hidebysig instance void - IncrementStaticProperty() cil managed + .method public hidebysig static void CustomStructBitOrTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: nop - IL_000e: ret - } // end of method CompoundAssignmentTest::IncrementStaticProperty + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_BitwiseOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructBitOrTest - .method public hidebysig instance void - DoubleStaticProperty() cil managed + .method public hidebysig static void CustomStructBitXorTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 15 (0xf) - .maxstack 8 + // Code size 509 (0x1fd) + .maxstack 3 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000d: nop - IL_000e: ret - } // end of method CompoundAssignmentTest::DoubleStaticProperty + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: ldloca.s V_0 + IL_0008: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_000e: ldloc.0 + IL_000f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0014: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0019: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001e: ldloca.s V_0 + IL_0020: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0026: ldloc.0 + IL_0027: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_002c: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0031: nop + IL_0032: ldarg.1 + IL_0033: dup + IL_0034: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0039: ldloca.s V_0 + IL_003b: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0041: ldloc.0 + IL_0042: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0047: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_004c: ldarg.1 + IL_004d: dup + IL_004e: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0053: ldloca.s V_0 + IL_0055: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_005b: ldloc.0 + IL_005c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0061: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0066: nop + IL_0067: ldarga.s s + IL_0069: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006e: dup + IL_006f: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0074: ldloca.s V_0 + IL_0076: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0082: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0087: ldarga.s s + IL_0089: dup + IL_008a: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008f: ldloca.s V_0 + IL_0091: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0097: ldloc.0 + IL_0098: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_009d: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00a2: nop + IL_00a3: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a8: dup + IL_00a9: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00ae: ldloca.s V_0 + IL_00b0: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00b6: ldloc.0 + IL_00b7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00bc: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00c1: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c6: dup + IL_00c7: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00cc: ldloca.s V_0 + IL_00ce: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00d4: ldloc.0 + IL_00d5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00da: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00df: nop + IL_00e0: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e5: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00ea: dup + IL_00eb: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f0: ldloca.s V_0 + IL_00f2: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00fe: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0103: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0108: dup + IL_0109: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010e: ldloca.s V_0 + IL_0110: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0116: ldloc.0 + IL_0117: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_011c: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0121: nop + IL_0122: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0127: dup + IL_0128: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_012d: ldloca.s V_0 + IL_012f: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0135: ldloc.0 + IL_0136: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_013b: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0140: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0145: dup + IL_0146: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_014b: ldloca.s V_0 + IL_014d: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0153: ldloc.0 + IL_0154: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0159: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_015e: nop + IL_015f: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0164: dup + IL_0165: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_016a: ldloca.s V_0 + IL_016c: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0172: ldloc.0 + IL_0173: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0178: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_017d: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0182: dup + IL_0183: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0188: ldloca.s V_0 + IL_018a: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0190: ldloc.0 + IL_0191: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0196: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_019b: nop + IL_019c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01a1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a6: dup + IL_01a7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01ac: ldloca.s V_0 + IL_01ae: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ba: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01bf: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c4: dup + IL_01c5: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01ca: ldloca.s V_0 + IL_01cc: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01d2: ldloc.0 + IL_01d3: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d8: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01dd: nop + IL_01de: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01e3: dup + IL_01e4: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e9: ldloca.s V_0 + IL_01eb: initobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_ExclusiveOr(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01f7: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01fc: ret + } // end of method CompoundAssignmentTest::CustomStructBitXorTest - .method public hidebysig instance int32 - DoubleStaticPropertyAndReturn() cil managed + .method public hidebysig static void CustomStructPostIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 20 (0x14) + // Code size 505 (0x1f9) .maxstack 2 - .locals init (int32 V_0) + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() - IL_0006: ldc.i4.2 - IL_0007: mul - IL_0008: dup - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticProperty(int32) - IL_000e: nop - IL_000f: stloc.0 - IL_0010: br.s IL_0012 - - IL_0012: ldloc.0 - IL_0013: ret - } // end of method CompoundAssignmentTest::DoubleStaticPropertyAndReturn + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: dup + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: dup + IL_001d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: stloc.0 + IL_0036: ldloc.0 + IL_0037: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006a: dup + IL_006b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0070: stloc.0 + IL_0071: ldloc.0 + IL_0072: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0077: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0082: nop + IL_0083: ldarga.s s + IL_0085: dup + IL_0086: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008b: stloc.0 + IL_008c: ldloc.0 + IL_008d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: nop + IL_0098: ldloc.0 + IL_0099: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009e: nop + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b6: ldloc.0 + IL_00b7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bc: nop + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d4: nop + IL_00d5: ldloc.0 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: nop + IL_00dc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: dup + IL_00e7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ec: stloc.0 + IL_00ed: ldloc.0 + IL_00ee: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: nop + IL_00ff: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0104: dup + IL_0105: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010a: stloc.0 + IL_010b: ldloc.0 + IL_010c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0111: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0116: nop + IL_0117: ldloc.0 + IL_0118: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011d: nop + IL_011e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0123: dup + IL_0124: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0129: stloc.0 + IL_012a: ldloc.0 + IL_012b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0130: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: nop + IL_013c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0141: dup + IL_0142: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0147: stloc.0 + IL_0148: ldloc.0 + IL_0149: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: nop + IL_0154: ldloc.0 + IL_0155: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015a: nop + IL_015b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0160: dup + IL_0161: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0166: stloc.0 + IL_0167: ldloc.0 + IL_0168: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0172: ldloc.0 + IL_0173: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0178: nop + IL_0179: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017e: dup + IL_017f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0184: stloc.0 + IL_0185: ldloc.0 + IL_0186: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0190: nop + IL_0191: ldloc.0 + IL_0192: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0197: nop + IL_0198: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_019d: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a2: dup + IL_01a3: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a8: stloc.0 + IL_01a9: ldloc.0 + IL_01aa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01af: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01ba: nop + IL_01bb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c0: dup + IL_01c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c6: stloc.0 + IL_01c7: ldloc.0 + IL_01c8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01cd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d2: nop + IL_01d3: ldloc.0 + IL_01d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d9: nop + IL_01da: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01df: dup + IL_01e0: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e5: stloc.0 + IL_01e6: ldloc.0 + IL_01e7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ec: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01f7: nop + IL_01f8: ret + } // end of method CompoundAssignmentTest::CustomStructPostIncTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PreIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPreIncTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) + // Code size 505 (0x1f9) .maxstack 2 - .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: dup - IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000f: nop - IL_0010: stloc.0 - IL_0011: br.s IL_0013 - - IL_0013: ldloc.0 - IL_0014: ret - } // end of method CompoundAssignmentTest::PreIncrementStaticPropertyShort + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: dup + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003a: stloc.0 + IL_003b: ldloc.0 + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0054: stloc.0 + IL_0055: ldloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006a: dup + IL_006b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0070: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0075: stloc.0 + IL_0076: ldloc.0 + IL_0077: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0082: nop + IL_0083: ldarga.s s + IL_0085: dup + IL_0086: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: nop + IL_0098: ldloc.0 + IL_0099: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009e: nop + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00af: stloc.0 + IL_00b0: ldloc.0 + IL_00b1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b6: ldloc.0 + IL_00b7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bc: nop + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cd: stloc.0 + IL_00ce: ldloc.0 + IL_00cf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d4: nop + IL_00d5: ldloc.0 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: nop + IL_00dc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: dup + IL_00e7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ec: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f1: stloc.0 + IL_00f2: ldloc.0 + IL_00f3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: nop + IL_00ff: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0104: dup + IL_0105: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010f: stloc.0 + IL_0110: ldloc.0 + IL_0111: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0116: nop + IL_0117: ldloc.0 + IL_0118: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011d: nop + IL_011e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0123: dup + IL_0124: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0129: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: nop + IL_013c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0141: dup + IL_0142: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0147: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014c: stloc.0 + IL_014d: ldloc.0 + IL_014e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: nop + IL_0154: ldloc.0 + IL_0155: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015a: nop + IL_015b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0160: dup + IL_0161: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0166: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016b: stloc.0 + IL_016c: ldloc.0 + IL_016d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0172: ldloc.0 + IL_0173: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0178: nop + IL_0179: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017e: dup + IL_017f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0184: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0189: stloc.0 + IL_018a: ldloc.0 + IL_018b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0190: nop + IL_0191: ldloc.0 + IL_0192: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0197: nop + IL_0198: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_019d: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a2: dup + IL_01a3: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ad: stloc.0 + IL_01ae: ldloc.0 + IL_01af: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01ba: nop + IL_01bb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c0: dup + IL_01c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c6: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01cb: stloc.0 + IL_01cc: ldloc.0 + IL_01cd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d2: nop + IL_01d3: ldloc.0 + IL_01d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d9: nop + IL_01da: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01df: dup + IL_01e0: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Increment(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ea: stloc.0 + IL_01eb: ldloc.0 + IL_01ec: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01f7: nop + IL_01f8: ret + } // end of method CompoundAssignmentTest::CustomStructPreIncTest - .method public hidebysig instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum - PostIncrementStaticPropertyShort() cil managed + .method public hidebysig static void CustomStructPostDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed { - // Code size 21 (0x15) - .maxstack 3 - .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum V_0) + // Code size 505 (0x1f9) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField IL_0006: dup - IL_0007: ldc.i4.1 - IL_0008: add - IL_0009: conv.i2 - IL_000a: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000f: nop - IL_0010: stloc.0 - IL_0011: br.s IL_0013 + IL_0007: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: dup + IL_001d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: stloc.0 + IL_0036: ldloc.0 + IL_0037: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: stloc.0 + IL_0050: ldloc.0 + IL_0051: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006a: dup + IL_006b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0070: stloc.0 + IL_0071: ldloc.0 + IL_0072: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0077: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0082: nop + IL_0083: ldarga.s s + IL_0085: dup + IL_0086: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008b: stloc.0 + IL_008c: ldloc.0 + IL_008d: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0092: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: nop + IL_0098: ldloc.0 + IL_0099: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009e: nop + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: stloc.0 + IL_00ab: ldloc.0 + IL_00ac: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00b1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b6: ldloc.0 + IL_00b7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bc: nop + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: stloc.0 + IL_00c9: ldloc.0 + IL_00ca: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d4: nop + IL_00d5: ldloc.0 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: nop + IL_00dc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: dup + IL_00e7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ec: stloc.0 + IL_00ed: ldloc.0 + IL_00ee: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: nop + IL_00ff: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0104: dup + IL_0105: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010a: stloc.0 + IL_010b: ldloc.0 + IL_010c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0111: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0116: nop + IL_0117: ldloc.0 + IL_0118: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011d: nop + IL_011e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0123: dup + IL_0124: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0129: stloc.0 + IL_012a: ldloc.0 + IL_012b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0130: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: nop + IL_013c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0141: dup + IL_0142: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0147: stloc.0 + IL_0148: ldloc.0 + IL_0149: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: nop + IL_0154: ldloc.0 + IL_0155: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015a: nop + IL_015b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0160: dup + IL_0161: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0166: stloc.0 + IL_0167: ldloc.0 + IL_0168: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0172: ldloc.0 + IL_0173: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0178: nop + IL_0179: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017e: dup + IL_017f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0184: stloc.0 + IL_0185: ldloc.0 + IL_0186: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_018b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0190: nop + IL_0191: ldloc.0 + IL_0192: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0197: nop + IL_0198: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_019d: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a2: dup + IL_01a3: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a8: stloc.0 + IL_01a9: ldloc.0 + IL_01aa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01af: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01ba: nop + IL_01bb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c0: dup + IL_01c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c6: stloc.0 + IL_01c7: ldloc.0 + IL_01c8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01cd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d2: nop + IL_01d3: ldloc.0 + IL_01d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d9: nop + IL_01da: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01df: dup + IL_01e0: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e5: stloc.0 + IL_01e6: ldloc.0 + IL_01e7: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ec: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01f7: nop + IL_01f8: ret + } // end of method CompoundAssignmentTest::CustomStructPostDecTest - IL_0013: ldloc.0 - IL_0014: ret - } // end of method CompoundAssignmentTest::PostIncrementStaticPropertyShort + .method public hidebysig static void CustomStructPreDecTest(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct p, + class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass c, + valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 s) cil managed + { + // Code size 505 (0x1f9) + .maxstack 2 + .locals init (valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct V_0) + IL_0000: nop + IL_0001: ldsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0006: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_000b: dup + IL_000c: stsfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customStructField + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0016: nop + IL_0017: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + IL_001c: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0021: dup + IL_0022: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0027: nop + IL_0028: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_002d: nop + IL_002e: ldarg.1 + IL_002f: dup + IL_0030: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0035: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_003a: stloc.0 + IL_003b: ldloc.0 + IL_003c: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0041: ldloc.0 + IL_0042: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0047: nop + IL_0048: ldarg.1 + IL_0049: dup + IL_004a: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_004f: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0054: stloc.0 + IL_0055: ldloc.0 + IL_0056: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_005b: nop + IL_005c: ldloc.0 + IL_005d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0062: nop + IL_0063: ldarga.s s + IL_0065: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_006a: dup + IL_006b: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_0070: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0075: stloc.0 + IL_0076: ldloc.0 + IL_0077: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_007c: ldloc.0 + IL_007d: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0082: nop + IL_0083: ldarga.s s + IL_0085: dup + IL_0086: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_008b: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0090: stloc.0 + IL_0091: ldloc.0 + IL_0092: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0097: nop + IL_0098: ldloc.0 + IL_0099: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_009e: nop + IL_009f: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00a4: dup + IL_00a5: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00aa: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00af: stloc.0 + IL_00b0: ldloc.0 + IL_00b1: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_00b6: ldloc.0 + IL_00b7: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00bc: nop + IL_00bd: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::customClassField + IL_00c2: dup + IL_00c3: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_00c8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00cd: stloc.0 + IL_00ce: ldloc.0 + IL_00cf: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00d4: nop + IL_00d5: ldloc.0 + IL_00d6: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00db: nop + IL_00dc: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_00e1: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_00e6: dup + IL_00e7: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00ec: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_00f1: stloc.0 + IL_00f2: ldloc.0 + IL_00f3: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_00f8: ldloc.0 + IL_00f9: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_00fe: nop + IL_00ff: ldsflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::otherCustomStructField + IL_0104: dup + IL_0105: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_010a: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_010f: stloc.0 + IL_0110: ldloc.0 + IL_0111: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0116: nop + IL_0117: ldloc.0 + IL_0118: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_011d: nop + IL_011e: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0123: dup + IL_0124: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0129: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_012e: stloc.0 + IL_012f: ldloc.0 + IL_0130: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0135: ldloc.0 + IL_0136: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_013b: nop + IL_013c: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + IL_0141: dup + IL_0142: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0147: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_014c: stloc.0 + IL_014d: ldloc.0 + IL_014e: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0153: nop + IL_0154: ldloc.0 + IL_0155: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_015a: nop + IL_015b: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_0160: dup + IL_0161: ldfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0166: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_016b: stloc.0 + IL_016c: ldloc.0 + IL_016d: stfld valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::CustomStructField + IL_0172: ldloc.0 + IL_0173: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0178: nop + IL_0179: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetClass() + IL_017e: dup + IL_017f: callvirt instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomStructProp() + IL_0184: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0189: stloc.0 + IL_018a: ldloc.0 + IL_018b: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_0190: nop + IL_0191: ldloc.0 + IL_0192: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_0197: nop + IL_0198: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_019d: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::CustomStructField + IL_01a2: dup + IL_01a3: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01a8: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ad: stloc.0 + IL_01ae: ldloc.0 + IL_01af: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01b4: ldloc.0 + IL_01b5: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01ba: nop + IL_01bb: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetStruct() + IL_01c0: dup + IL_01c1: call instance valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::get_CustomStructProp() + IL_01c6: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01cb: stloc.0 + IL_01cc: ldloc.0 + IL_01cd: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct2::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01d2: nop + IL_01d3: ldloc.0 + IL_01d4: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01d9: nop + IL_01da: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct& ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::GetRefCustomStruct() + IL_01df: dup + IL_01e0: ldobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01e5: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct::op_Decrement(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + IL_01ea: stloc.0 + IL_01eb: ldloc.0 + IL_01ec: stobj ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + IL_01f1: ldloc.0 + IL_01f2: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::X(!!0) + IL_01f7: nop + IL_01f8: ret + } // end of method CompoundAssignmentTest::CustomStructPreDecTest - .method public hidebysig instance void - IncrementStaticPropertyShort() cil managed + .method public hidebysig static void AddOneToCustomClass(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass& c) cil managed { - // Code size 16 (0x10) + // Code size 32 (0x20) .maxstack 8 IL_0000: nop - IL_0001: call valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticShortProperty() - IL_0006: ldc.i4.1 - IL_0007: add - IL_0008: conv.i2 - IL_0009: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_StaticShortProperty(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/ShortEnum) - IL_000e: nop - IL_000f: ret - } // end of method CompoundAssignmentTest::IncrementStaticPropertyShort + IL_0001: ldarg.0 + IL_0002: ldarg.0 + IL_0003: ldind.ref + IL_0004: ldc.i4.1 + IL_0005: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_000a: stind.ref + IL_000b: ldarg.0 + IL_000c: ldind.ref + IL_000d: dup + IL_000e: callvirt instance class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::get_CustomClassProp() + IL_0013: ldc.i4.1 + IL_0014: call class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::op_Addition(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass, + int32) + IL_0019: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + IL_001e: nop + IL_001f: ret + } // end of method CompoundAssignmentTest::AddOneToCustomClass .method private hidebysig static class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/Item GetItem(object obj) cil managed @@ -1951,27 +25399,22 @@ .method private hidebysig instance void Issue588(uint16 val) cil managed { - // Code size 33 (0x21) - .maxstack 4 - .locals init (uint16 V_0) + // Code size 29 (0x1d) + .maxstack 8 IL_0000: nop IL_0001: ldarg.0 IL_0002: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortDict - IL_0007: ldarg.0 - IL_0008: ldarg.0 - IL_0009: ldfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_000e: stloc.0 - IL_000f: ldloc.0 - IL_0010: ldc.i4.1 - IL_0011: add - IL_0012: conv.u2 - IL_0013: stfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField - IL_0018: ldloc.0 - IL_0019: ldarg.1 - IL_001a: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, + IL_0007: ldsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_000c: dup + IL_000d: ldc.i4.1 + IL_000e: add + IL_000f: conv.u2 + IL_0010: stsfld uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::ushortField + IL_0015: ldarg.1 + IL_0016: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) - IL_001f: nop - IL_0020: ret + IL_001b: nop + IL_001c: ret } // end of method CompoundAssignmentTest::Issue588 .method private hidebysig instance void @@ -2018,6 +25461,58 @@ IL_0012: ret } // end of method CompoundAssignmentTest::.ctor + .property class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass + CustomClassProp() + { + .get class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomClassProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomClassProp(class ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomClass) + } // end of property CompoundAssignmentTest::CustomClassProp + .property valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct + CustomStructProp() + { + .get valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_CustomStructProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_CustomStructProp(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest/CustomStruct) + } // end of property CompoundAssignmentTest::CustomStructProp + .property uint8 ByteProp() + { + .get uint8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ByteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ByteProp(uint8) + } // end of property CompoundAssignmentTest::ByteProp + .property int8 SbyteProp() + { + .get int8 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_SbyteProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_SbyteProp(int8) + } // end of property CompoundAssignmentTest::SbyteProp + .property int16 ShortProp() + { + .get int16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_ShortProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_ShortProp(int16) + } // end of property CompoundAssignmentTest::ShortProp + .property uint16 UshortProp() + { + .get uint16 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UshortProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UshortProp(uint16) + } // end of property CompoundAssignmentTest::UshortProp + .property int32 IntProp() + { + .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_IntProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_IntProp(int32) + } // end of property CompoundAssignmentTest::IntProp + .property uint32 UintProp() + { + .get uint32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UintProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UintProp(uint32) + } // end of property CompoundAssignmentTest::UintProp + .property int64 LongProp() + { + .get int64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_LongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_LongProp(int64) + } // end of property CompoundAssignmentTest::LongProp + .property uint64 UlongProp() + { + .get uint64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_UlongProp() + .set void ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::set_UlongProp(uint64) + } // end of property CompoundAssignmentTest::UlongProp .property int32 StaticProperty() { .get int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.CompoundAssignmentTest::get_StaticProperty() diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.il index ff6fa69d0..5037e3872 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly awc2kjfz +.assembly DelegateConstruction { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) @@ -26,15 +24,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module awc2kjfz.dll -// MVID: {49C8B10E-CA57-40C1-9484-BC8636C38817} +.module DelegateConstruction.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04D50000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1763,4 +1759,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\DelegateConstruction.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.opt.il index 8d2c56f1d..4e96ae785 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly ci3jaj4f +.assembly DelegateConstruction.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.ExtensionAttribute::.ctor() = ( 01 00 00 00 ) @@ -26,15 +24,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module ci3jaj4f.dll -// MVID: {F860E23B-9B90-453A-A3A5-49C4D5AA91F8} +.module DelegateConstruction.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x05340000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1460,4 +1456,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\DelegateConstruction.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.cs index e73422857..65c9b0e12 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.cs @@ -188,6 +188,12 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty } } - + public void ThrowInFinally() + { + try { + } finally { + throw new Exception(); + } + } } } \ No newline at end of file diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.il index a2159701a..da21e9e03 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly vicbdq3v +.assembly ExceptionHandling { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module vicbdq3v.dll -// MVID: {5E2AA050-D333-4323-8C5A-29B86C8D98BB} +.module ExceptionHandling.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x01160000 // =============== CLASS MEMBERS DECLARATION =================== @@ -415,6 +411,29 @@ IL_0022: ret } // end of method ExceptionHandling::NoUsingStatementBecauseTheVariableIsAssignedTo + .method public hidebysig instance void + ThrowInFinally() cil managed + { + // Code size 14 (0xe) + .maxstack 1 + IL_0000: nop + .try + { + IL_0001: nop + IL_0002: nop + IL_0003: leave.s IL_000c + + } // end .try + finally + { + IL_0005: nop + IL_0006: newobj instance void [mscorlib]System.Exception::.ctor() + IL_000b: throw + + } // end handler + IL_000c: br.s IL_000c + } // end of method ExceptionHandling::ThrowInFinally + .method family hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -431,4 +450,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ExceptionHandling.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.il index 19e1de7c6..1c840804b 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly uidw4n1e +.assembly ExceptionHandling.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module uidw4n1e.dll -// MVID: {A6A100AA-2C72-4B40-9C9F-50DA438D4727} +.module ExceptionHandling.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00380000 // =============== CLASS MEMBERS DECLARATION =================== @@ -322,6 +318,25 @@ IL_0014: ret } // end of method ExceptionHandling::NoUsingStatementBecauseTheVariableIsAssignedTo + .method public hidebysig instance void + ThrowInFinally() cil managed + { + // Code size 10 (0xa) + .maxstack 1 + .try + { + IL_0000: leave.s IL_0008 + + } // end .try + finally + { + IL_0002: newobj instance void [mscorlib]System.Exception::.ctor() + IL_0007: throw + + } // end handler + IL_0008: br.s IL_0008 + } // end of method ExceptionHandling::ThrowInFinally + .method family hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -338,4 +353,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ExceptionHandling.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.roslyn.il index 6df69b2d7..6ea9bd327 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.opt.roslyn.il @@ -670,6 +670,25 @@ IL_0014: ret } // end of method ExceptionHandling::NoUsingStatementBecauseTheVariableIsAssignedTo + .method public hidebysig instance void + ThrowInFinally() cil managed + { + // Code size 10 (0xa) + .maxstack 1 + .try + { + IL_0000: leave.s IL_0008 + + } // end .try + finally + { + IL_0002: newobj instance void [mscorlib]System.Exception::.ctor() + IL_0007: throw + + } // end handler + IL_0008: br.s IL_0008 + } // end of method ExceptionHandling::ThrowInFinally + .method family hidebysig specialname rtspecialname instance void .ctor() cil managed { diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.roslyn.il index 9b1384184..dce07ee7d 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExceptionHandling.roslyn.il @@ -831,6 +831,29 @@ IL_0021: ret } // end of method ExceptionHandling::NoUsingStatementBecauseTheVariableIsAssignedTo + .method public hidebysig instance void + ThrowInFinally() cil managed + { + // Code size 14 (0xe) + .maxstack 1 + IL_0000: nop + .try + { + IL_0001: nop + IL_0002: nop + IL_0003: leave.s IL_000c + + } // end .try + finally + { + IL_0005: nop + IL_0006: newobj instance void [mscorlib]System.Exception::.ctor() + IL_000b: throw + + } // end handler + IL_000c: br.s IL_000c + } // end of method ExceptionHandling::ThrowInFinally + .method family hidebysig specialname rtspecialname instance void .ctor() cil managed { diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.cs index db40b39b1..8021c6b14 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.cs @@ -218,7 +218,7 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty public void MembersBuiltin() { ToCode(X(), () => 1.23m.ToString()); - ToCode(X(), () => ((Enum)(object)AttributeTargets.All).HasFlag((Enum)AttributeTargets.Assembly)); + ToCode(X(), () => AttributeTargets.All.HasFlag((Enum)AttributeTargets.Assembly)); ToCode(X(), () => "abc".Length == 3); ToCode(X(), () => 'a'.CompareTo('b') < 0); } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.il index 75cd310b8..7851777f2 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -20,7 +18,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '3qhjq0hu' +.assembly ExpressionTrees { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -30,15 +28,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '3qhjq0hu.dll' -// MVID: {426C7905-90B3-4EA8-8585-F907E00CBDB7} +.module ExpressionTrees.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02FC0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -9909,7 +9905,7 @@ IL_0000: ldc.i4.3 IL_0001: newarr [mscorlib]System.Int32 IL_0006: dup - IL_0007: ldtoken field valuetype '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'/'__StaticArrayInitTypeSize=12' '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'::'$$method0x60000bc-1' + IL_0007: ldtoken field valuetype ''/'__StaticArrayInitTypeSize=12' ''::'$$method0x60000bc-1' IL_000c: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle) IL_0011: stloc.0 @@ -9985,7 +9981,7 @@ IL_0009: ldc.i4.3 IL_000a: newarr [mscorlib]System.Int32 IL_000f: dup - IL_0010: ldtoken field valuetype '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'/'__StaticArrayInitTypeSize=12' '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'::'$$method0x60000c0-1' + IL_0010: ldtoken field valuetype ''/'__StaticArrayInitTypeSize=12' ''::'$$method0x60000c0-1' IL_0015: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle) IL_001a: stelem.ref @@ -10676,7 +10672,7 @@ } // end of property '<>f__AnonymousType1`2'::Y } // end of class '<>f__AnonymousType1`2' -.class private auto ansi '{426C7905-90B3-4EA8-8585-F907E00CBDB7}' +.class private auto ansi '' extends [mscorlib]System.Object { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) @@ -10687,9 +10683,9 @@ .size 12 } // end of class '__StaticArrayInitTypeSize=12' - .field static assembly valuetype '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'/'__StaticArrayInitTypeSize=12' '$$method0x60000bc-1' at I_00007A38 - .field static assembly valuetype '{426C7905-90B3-4EA8-8585-F907E00CBDB7}'/'__StaticArrayInitTypeSize=12' '$$method0x60000c0-1' at I_00007AB0 -} // end of class '{426C7905-90B3-4EA8-8585-F907E00CBDB7}' + .field static assembly valuetype ''/'__StaticArrayInitTypeSize=12' '$$method0x60000bc-1' at I_00007A38 + .field static assembly valuetype ''/'__StaticArrayInitTypeSize=12' '$$method0x60000c0-1' at I_00007AB0 +} // end of class '' .class private auto ansi sealed beforefieldinit '<>f__AnonymousType2`2'<'j__TPar','j__TPar'> extends [mscorlib]System.Object @@ -10886,4 +10882,3 @@ .data cil I_00007AB0 = bytearray ( 01 00 00 00 02 00 00 00 03 00 00 00) // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ExpressionTrees.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.il index 18d861a19..2b5df10f2 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -20,7 +18,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly tngduxjw +.assembly ExpressionTrees.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -30,15 +28,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tngduxjw.dll -// MVID: {416BD71B-B506-4355-8604-9F8C6A2FDEE6} +.module ExpressionTrees.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04A60000 // =============== CLASS MEMBERS DECLARATION =================== @@ -9453,7 +9449,7 @@ IL_0000: ldc.i4.3 IL_0001: newarr [mscorlib]System.Int32 IL_0006: dup - IL_0007: ldtoken field valuetype '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'/'__StaticArrayInitTypeSize=12' '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'::'$$method0x60000bc-1' + IL_0007: ldtoken field valuetype ''/'__StaticArrayInitTypeSize=12' ''::'$$method0x60000bc-1' IL_000c: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle) IL_0011: ret @@ -9509,7 +9505,7 @@ IL_0009: ldc.i4.3 IL_000a: newarr [mscorlib]System.Int32 IL_000f: dup - IL_0010: ldtoken field valuetype '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'/'__StaticArrayInitTypeSize=12' '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'::'$$method0x60000c0-1' + IL_0010: ldtoken field valuetype ''/'__StaticArrayInitTypeSize=12' ''::'$$method0x60000c0-1' IL_0015: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle) IL_001a: stelem.ref @@ -10095,7 +10091,7 @@ } // end of property '<>f__AnonymousType1`2'::Y } // end of class '<>f__AnonymousType1`2' -.class private auto ansi '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}' +.class private auto ansi '' extends [mscorlib]System.Object { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) @@ -10106,9 +10102,9 @@ .size 12 } // end of class '__StaticArrayInitTypeSize=12' - .field static assembly valuetype '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'/'__StaticArrayInitTypeSize=12' '$$method0x60000bc-1' at I_00007670 - .field static assembly valuetype '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}'/'__StaticArrayInitTypeSize=12' '$$method0x60000c0-1' at I_000076A8 -} // end of class '{416BD71B-B506-4355-8604-9F8C6A2FDEE6}' + .field static assembly valuetype ''/'__StaticArrayInitTypeSize=12' '$$method0x60000bc-1' at I_00007670 + .field static assembly valuetype ''/'__StaticArrayInitTypeSize=12' '$$method0x60000c0-1' at I_000076A8 +} // end of class '' .class private auto ansi sealed beforefieldinit '<>f__AnonymousType2`2'<'j__TPar','j__TPar'> extends [mscorlib]System.Object @@ -10279,4 +10275,3 @@ .data cil I_000076A8 = bytearray ( 01 00 00 00 02 00 00 00 03 00 00 00) // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ExpressionTrees.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.roslyn.il index 0615e20b2..3edddc6b0 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.opt.roslyn.il @@ -3117,7 +3117,7 @@ .method public hidebysig instance void MembersBuiltin() cil managed { - // Code size 431 (0x1af) + // Code size 401 (0x191) .maxstack 8 IL_0000: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() IL_0005: ldc.i4.s 123 @@ -3157,108 +3157,100 @@ IL_0063: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) IL_0068: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_006d: ldtoken [mscorlib]System.Object - IL_0072: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0077: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, - class [mscorlib]System.Type) - IL_007c: ldtoken [mscorlib]System.Enum - IL_0081: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0086: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, - class [mscorlib]System.Type) - IL_008b: ldtoken method instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) - IL_0090: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_0095: castclass [mscorlib]System.Reflection.MethodInfo - IL_009a: ldc.i4.1 - IL_009b: newarr [System.Core]System.Linq.Expressions.Expression - IL_00a0: dup - IL_00a1: ldc.i4.0 - IL_00a2: ldc.i4.1 - IL_00a3: box [mscorlib]System.AttributeTargets - IL_00a8: ldtoken [mscorlib]System.AttributeTargets - IL_00ad: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00b2: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_00b7: ldtoken [mscorlib]System.Enum - IL_00bc: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00c1: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, + IL_006d: ldtoken method instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0072: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_0077: castclass [mscorlib]System.Reflection.MethodInfo + IL_007c: ldc.i4.1 + IL_007d: newarr [System.Core]System.Linq.Expressions.Expression + IL_0082: dup + IL_0083: ldc.i4.0 + IL_0084: ldc.i4.1 + IL_0085: box [mscorlib]System.AttributeTargets + IL_008a: ldtoken [mscorlib]System.AttributeTargets + IL_008f: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_0094: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_0099: ldtoken [mscorlib]System.Enum + IL_009e: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00a3: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Type) - IL_00c6: stelem.ref - IL_00c7: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, + IL_00a8: stelem.ref + IL_00a9: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo, class [System.Core]System.Linq.Expressions.Expression[]) - IL_00cc: ldc.i4.0 - IL_00cd: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_00d2: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_00ae: ldc.i4.0 + IL_00af: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_00b4: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_00d7: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_00b9: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_00dc: pop - IL_00dd: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() - IL_00e2: ldstr "abc" - IL_00e7: ldtoken [mscorlib]System.String - IL_00ec: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00f1: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_00f6: ldtoken method instance int32 [mscorlib]System.String::get_Length() - IL_00fb: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_0100: castclass [mscorlib]System.Reflection.MethodInfo - IL_0105: call class [System.Core]System.Linq.Expressions.MemberExpression [System.Core]System.Linq.Expressions.Expression::Property(class [System.Core]System.Linq.Expressions.Expression, + IL_00be: pop + IL_00bf: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() + IL_00c4: ldstr "abc" + IL_00c9: ldtoken [mscorlib]System.String + IL_00ce: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00d3: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_00d8: ldtoken method instance int32 [mscorlib]System.String::get_Length() + IL_00dd: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_00e2: castclass [mscorlib]System.Reflection.MethodInfo + IL_00e7: call class [System.Core]System.Linq.Expressions.MemberExpression [System.Core]System.Linq.Expressions.Expression::Property(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo) - IL_010a: ldc.i4.3 - IL_010b: box [mscorlib]System.Int32 - IL_0110: ldtoken [mscorlib]System.Int32 - IL_0115: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_011a: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + IL_00ec: ldc.i4.3 + IL_00ed: box [mscorlib]System.Int32 + IL_00f2: ldtoken [mscorlib]System.Int32 + IL_00f7: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00fc: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_011f: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::Equal(class [System.Core]System.Linq.Expressions.Expression, + IL_0101: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::Equal(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.Expression) - IL_0124: ldc.i4.0 - IL_0125: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_012a: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_0106: ldc.i4.0 + IL_0107: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_010c: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_012f: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_0111: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_0134: pop - IL_0135: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() - IL_013a: ldc.i4.s 97 - IL_013c: box [mscorlib]System.Char - IL_0141: ldtoken [mscorlib]System.Char - IL_0146: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_014b: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_0150: ldtoken method instance int32 [mscorlib]System.Char::CompareTo(char) - IL_0155: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_015a: castclass [mscorlib]System.Reflection.MethodInfo - IL_015f: ldc.i4.1 - IL_0160: newarr [System.Core]System.Linq.Expressions.Expression - IL_0165: dup - IL_0166: ldc.i4.0 - IL_0167: ldc.i4.s 98 - IL_0169: box [mscorlib]System.Char - IL_016e: ldtoken [mscorlib]System.Char - IL_0173: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0178: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_017d: stelem.ref - IL_017e: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, + IL_0116: pop + IL_0117: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() + IL_011c: ldc.i4.s 97 + IL_011e: box [mscorlib]System.Char + IL_0123: ldtoken [mscorlib]System.Char + IL_0128: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_012d: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_0132: ldtoken method instance int32 [mscorlib]System.Char::CompareTo(char) + IL_0137: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_013c: castclass [mscorlib]System.Reflection.MethodInfo + IL_0141: ldc.i4.1 + IL_0142: newarr [System.Core]System.Linq.Expressions.Expression + IL_0147: dup + IL_0148: ldc.i4.0 + IL_0149: ldc.i4.s 98 + IL_014b: box [mscorlib]System.Char + IL_0150: ldtoken [mscorlib]System.Char + IL_0155: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_015a: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_015f: stelem.ref + IL_0160: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo, class [System.Core]System.Linq.Expressions.Expression[]) - IL_0183: ldc.i4.0 - IL_0184: box [mscorlib]System.Int32 - IL_0189: ldtoken [mscorlib]System.Int32 - IL_018e: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0193: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + IL_0165: ldc.i4.0 + IL_0166: box [mscorlib]System.Int32 + IL_016b: ldtoken [mscorlib]System.Int32 + IL_0170: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_0175: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_0198: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::LessThan(class [System.Core]System.Linq.Expressions.Expression, + IL_017a: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::LessThan(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.Expression) - IL_019d: ldc.i4.0 - IL_019e: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_01a3: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_017f: ldc.i4.0 + IL_0180: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_0185: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_01a8: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_018a: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_01ad: pop - IL_01ae: ret + IL_018f: pop + IL_0190: ret } // end of method ExpressionTrees::MembersBuiltin .method public hidebysig instance void @@ -9680,12 +9672,12 @@ .size 12 } // end of class '__StaticArrayInitTypeSize=12' - .field static assembly initonly valuetype ''/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_0000BDA0 + .field static assembly initonly valuetype ''/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_0000BD84 } // end of class '' // ============================================================= -.data cil I_0000BDA0 = bytearray ( +.data cil I_0000BD84 = bytearray ( 01 00 00 00 02 00 00 00 03 00 00 00) // *********** DISASSEMBLY COMPLETE *********************** diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.roslyn.il index cf337256e..ab5a7c704 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ExpressionTrees.roslyn.il @@ -3201,7 +3201,7 @@ .method public hidebysig instance void MembersBuiltin() cil managed { - // Code size 432 (0x1b0) + // Code size 402 (0x192) .maxstack 8 IL_0000: nop IL_0001: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() @@ -3242,108 +3242,100 @@ IL_0064: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) IL_0069: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_006e: ldtoken [mscorlib]System.Object - IL_0073: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0078: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, - class [mscorlib]System.Type) - IL_007d: ldtoken [mscorlib]System.Enum - IL_0082: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0087: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, - class [mscorlib]System.Type) - IL_008c: ldtoken method instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) - IL_0091: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_0096: castclass [mscorlib]System.Reflection.MethodInfo - IL_009b: ldc.i4.1 - IL_009c: newarr [System.Core]System.Linq.Expressions.Expression - IL_00a1: dup - IL_00a2: ldc.i4.0 - IL_00a3: ldc.i4.1 - IL_00a4: box [mscorlib]System.AttributeTargets - IL_00a9: ldtoken [mscorlib]System.AttributeTargets - IL_00ae: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00b3: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_00b8: ldtoken [mscorlib]System.Enum - IL_00bd: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00c2: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, + IL_006e: ldtoken method instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0073: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_0078: castclass [mscorlib]System.Reflection.MethodInfo + IL_007d: ldc.i4.1 + IL_007e: newarr [System.Core]System.Linq.Expressions.Expression + IL_0083: dup + IL_0084: ldc.i4.0 + IL_0085: ldc.i4.1 + IL_0086: box [mscorlib]System.AttributeTargets + IL_008b: ldtoken [mscorlib]System.AttributeTargets + IL_0090: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_0095: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_009a: ldtoken [mscorlib]System.Enum + IL_009f: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00a4: call class [System.Core]System.Linq.Expressions.UnaryExpression [System.Core]System.Linq.Expressions.Expression::Convert(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Type) - IL_00c7: stelem.ref - IL_00c8: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, + IL_00a9: stelem.ref + IL_00aa: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo, class [System.Core]System.Linq.Expressions.Expression[]) - IL_00cd: ldc.i4.0 - IL_00ce: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_00d3: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_00af: ldc.i4.0 + IL_00b0: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_00b5: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_00d8: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_00ba: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_00dd: pop - IL_00de: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() - IL_00e3: ldstr "abc" - IL_00e8: ldtoken [mscorlib]System.String - IL_00ed: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_00f2: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_00f7: ldtoken method instance int32 [mscorlib]System.String::get_Length() - IL_00fc: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_0101: castclass [mscorlib]System.Reflection.MethodInfo - IL_0106: call class [System.Core]System.Linq.Expressions.MemberExpression [System.Core]System.Linq.Expressions.Expression::Property(class [System.Core]System.Linq.Expressions.Expression, + IL_00bf: pop + IL_00c0: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() + IL_00c5: ldstr "abc" + IL_00ca: ldtoken [mscorlib]System.String + IL_00cf: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00d4: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_00d9: ldtoken method instance int32 [mscorlib]System.String::get_Length() + IL_00de: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_00e3: castclass [mscorlib]System.Reflection.MethodInfo + IL_00e8: call class [System.Core]System.Linq.Expressions.MemberExpression [System.Core]System.Linq.Expressions.Expression::Property(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo) - IL_010b: ldc.i4.3 - IL_010c: box [mscorlib]System.Int32 - IL_0111: ldtoken [mscorlib]System.Int32 - IL_0116: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_011b: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + IL_00ed: ldc.i4.3 + IL_00ee: box [mscorlib]System.Int32 + IL_00f3: ldtoken [mscorlib]System.Int32 + IL_00f8: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_00fd: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_0120: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::Equal(class [System.Core]System.Linq.Expressions.Expression, + IL_0102: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::Equal(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.Expression) - IL_0125: ldc.i4.0 - IL_0126: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_012b: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_0107: ldc.i4.0 + IL_0108: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_010d: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_0130: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_0112: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_0135: pop - IL_0136: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() - IL_013b: ldc.i4.s 97 - IL_013d: box [mscorlib]System.Char - IL_0142: ldtoken [mscorlib]System.Char - IL_0147: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_014c: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_0151: ldtoken method instance int32 [mscorlib]System.Char::CompareTo(char) - IL_0156: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) - IL_015b: castclass [mscorlib]System.Reflection.MethodInfo - IL_0160: ldc.i4.1 - IL_0161: newarr [System.Core]System.Linq.Expressions.Expression - IL_0166: dup - IL_0167: ldc.i4.0 - IL_0168: ldc.i4.s 98 - IL_016a: box [mscorlib]System.Char - IL_016f: ldtoken [mscorlib]System.Char - IL_0174: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0179: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, - class [mscorlib]System.Type) - IL_017e: stelem.ref - IL_017f: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, + IL_0117: pop + IL_0118: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::X() + IL_011d: ldc.i4.s 97 + IL_011f: box [mscorlib]System.Char + IL_0124: ldtoken [mscorlib]System.Char + IL_0129: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_012e: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_0133: ldtoken method instance int32 [mscorlib]System.Char::CompareTo(char) + IL_0138: call class [mscorlib]System.Reflection.MethodBase [mscorlib]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [mscorlib]System.RuntimeMethodHandle) + IL_013d: castclass [mscorlib]System.Reflection.MethodInfo + IL_0142: ldc.i4.1 + IL_0143: newarr [System.Core]System.Linq.Expressions.Expression + IL_0148: dup + IL_0149: ldc.i4.0 + IL_014a: ldc.i4.s 98 + IL_014c: box [mscorlib]System.Char + IL_0151: ldtoken [mscorlib]System.Char + IL_0156: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_015b: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + class [mscorlib]System.Type) + IL_0160: stelem.ref + IL_0161: call class [System.Core]System.Linq.Expressions.MethodCallExpression [System.Core]System.Linq.Expressions.Expression::Call(class [System.Core]System.Linq.Expressions.Expression, class [mscorlib]System.Reflection.MethodInfo, class [System.Core]System.Linq.Expressions.Expression[]) - IL_0184: ldc.i4.0 - IL_0185: box [mscorlib]System.Int32 - IL_018a: ldtoken [mscorlib]System.Int32 - IL_018f: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) - IL_0194: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, + IL_0166: ldc.i4.0 + IL_0167: box [mscorlib]System.Int32 + IL_016c: ldtoken [mscorlib]System.Int32 + IL_0171: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) + IL_0176: call class [System.Core]System.Linq.Expressions.ConstantExpression [System.Core]System.Linq.Expressions.Expression::Constant(object, class [mscorlib]System.Type) - IL_0199: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::LessThan(class [System.Core]System.Linq.Expressions.Expression, + IL_017b: call class [System.Core]System.Linq.Expressions.BinaryExpression [System.Core]System.Linq.Expressions.Expression::LessThan(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.Expression) - IL_019e: ldc.i4.0 - IL_019f: newarr [System.Core]System.Linq.Expressions.ParameterExpression - IL_01a4: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, + IL_0180: ldc.i4.0 + IL_0181: newarr [System.Core]System.Linq.Expressions.ParameterExpression + IL_0186: call class [System.Core]System.Linq.Expressions.Expression`1 [System.Core]System.Linq.Expressions.Expression::Lambda>(class [System.Core]System.Linq.Expressions.Expression, class [System.Core]System.Linq.Expressions.ParameterExpression[]) - IL_01a9: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, + IL_018b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.ExpressionTrees::ToCode(object, class [System.Core]System.Linq.Expressions.Expression`1>) - IL_01ae: pop - IL_01af: ret + IL_0190: pop + IL_0191: ret } // end of method ExpressionTrees::MembersBuiltin .method public hidebysig instance void @@ -9927,12 +9919,12 @@ .size 12 } // end of class '__StaticArrayInitTypeSize=12' - .field static assembly initonly valuetype ''/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_0000C030 + .field static assembly initonly valuetype ''/'__StaticArrayInitTypeSize=12' E429CCA3F703A39CC5954A6572FEC9086135B34E at I_0000C014 } // end of class '' // ============================================================= -.data cil I_0000C030 = bytearray ( +.data cil I_0000C014 = bytearray ( 01 00 00 00 02 00 00 00 03 00 00 00) // *********** DISASSEMBLY COMPLETE *********************** diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.cs index 7d3fe0b20..35a6e5740 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.cs @@ -32,7 +32,7 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.ILPretty { protected internal IEnumerable Test2(string test) { - yield return Test(test); + yield return base.Test(test); } } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.il index 69f149030..46f043472 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. Alle Rechte vorbehalten. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly kjibydgt +.assembly FixProxyCalls { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module kjibydgt.dll -// MVID: {7F7E319E-D28C-421B-B3A6-A5F71C1BC3A5} +.module FixProxyCalls.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02700000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1576,4 +1572,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// Warnung: Win32-Ressourcendatei "../../../TestCases/Pretty\FixProxyCalls.res" wurde erstellt. diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.opt.il index b26753120..1ccf080d3 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/FixProxyCalls.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. Alle Rechte vorbehalten. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly b0rqcnnq +.assembly FixProxyCalls.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module b0rqcnnq.dll -// MVID: {D8989CD1-06F3-4E8C-8C4C-7F7B95ACB488} +.module FixProxyCalls.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00810000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1320,4 +1316,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// Warnung: Win32-Ressourcendatei "../../../TestCases/Pretty\FixProxyCalls.opt.res" wurde erstellt. diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.il index c835b44a6..cea2aa8fe 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly hdkktc2j +.assembly Generics { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module hdkktc2j.dll -// MVID: {E1E1D350-F9F6-4498-A05D-8F728F6F95CE} +.module Generics.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04410000 // =============== CLASS MEMBERS DECLARATION =================== @@ -310,4 +306,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Generics.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.opt.il index 9ec6d12fe..283cbc0d3 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Generics.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly qmjsj0bc +.assembly Generics.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module qmjsj0bc.dll -// MVID: {A13EDBC1-FA83-4831-BCEB-F1A730B462DC} +.module Generics.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03640000 // =============== CLASS MEMBERS DECLARATION =================== @@ -243,4 +239,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Generics.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/HelloWorld.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/HelloWorld.il index e4562f2a0..556198c5a 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/HelloWorld.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/HelloWorld.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '5iai3vtm' +.assembly HelloWorld { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '5iai3vtm.dll' -// MVID: {66BA676E-A1AF-4531-9C09-198436A0A184} +.module HelloWorld.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00CC0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -63,4 +59,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../Tests/TestCases/Pretty\HelloWorld.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.cs index 87cd568f8..2179a6a82 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.cs @@ -197,6 +197,27 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty return c; } + public static void InvalidIndices(int a) + { + int[] array = new int[1]; + array[1] = a; + X(Y(), array); + } + + public static void InvalidIndices2(int a) + { + int[] array = new int[1]; + array[-1] = a; + X(Y(), array); + } + + public static void IndicesInWrongOrder(int a, int b) + { + int[] array = new int[5]; + array[2] = b; + array[1] = a; + X(Y(), array); + } public static void CollectionInitializerList() { diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.il index e4dc50f38..f6cc954c2 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly rzivg0mq +.assembly InitializerTests { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -25,15 +23,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module rzivg0mq.dll -// MVID: {66592AAC-07E3-4F52-A96F-0428775E7A0F} +.module InitializerTests.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00E00000 // =============== CLASS MEMBERS DECLARATION =================== @@ -775,6 +771,74 @@ IL_002b: ret } // end of method InitializerTests::Test4 + .method public hidebysig static void InvalidIndices(int32 a) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.1 + IL_000a: ldarg.0 + IL_000b: stelem.i4 + IL_000c: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0011: ldloc.0 + IL_0012: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0017: nop + IL_0018: ret + } // end of method InitializerTests::InvalidIndices + + .method public hidebysig static void InvalidIndices2(int32 a) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.m1 + IL_000a: ldarg.0 + IL_000b: stelem.i4 + IL_000c: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0011: ldloc.0 + IL_0012: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0017: nop + IL_0018: ret + } // end of method InitializerTests::InvalidIndices2 + + .method public hidebysig static void IndicesInWrongOrder(int32 a, + int32 b) cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.5 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.2 + IL_000a: ldarg.1 + IL_000b: stelem.i4 + IL_000c: ldloc.0 + IL_000d: ldc.i4.1 + IL_000e: ldarg.0 + IL_000f: stelem.i4 + IL_0010: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0015: ldloc.0 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_001b: nop + IL_001c: ret + } // end of method InitializerTests::IndicesInWrongOrder + .method public hidebysig static void CollectionInitializerList() cil managed { // Code size 44 (0x2c) @@ -1549,4 +1613,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\InitializerTests.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.il index 0719f6acd..2afbef293 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly n52bfodk +.assembly InitializerTests.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -25,15 +23,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module n52bfodk.dll -// MVID: {2B30E2AC-D797-4A69-ACEC-93251C343504} +.module InitializerTests.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x037A0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -658,6 +654,68 @@ IL_0026: ret } // end of method InitializerTests::Test4 + .method public hidebysig static void InvalidIndices(int32 a) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.1 + IL_0009: ldarg.0 + IL_000a: stelem.i4 + IL_000b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0010: ldloc.0 + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0016: ret + } // end of method InitializerTests::InvalidIndices + + .method public hidebysig static void InvalidIndices2(int32 a) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.m1 + IL_0009: ldarg.0 + IL_000a: stelem.i4 + IL_000b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0010: ldloc.0 + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0016: ret + } // end of method InitializerTests::InvalidIndices2 + + .method public hidebysig static void IndicesInWrongOrder(int32 a, + int32 b) cil managed + { + // Code size 27 (0x1b) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.5 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.2 + IL_0009: ldarg.1 + IL_000a: stelem.i4 + IL_000b: ldloc.0 + IL_000c: ldc.i4.1 + IL_000d: ldarg.0 + IL_000e: stelem.i4 + IL_000f: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0014: ldloc.0 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_001a: ret + } // end of method InitializerTests::IndicesInWrongOrder + .method public hidebysig static void CollectionInitializerList() cil managed { // Code size 39 (0x27) @@ -1304,4 +1362,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\InitializerTests.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.roslyn.il index a4e50211e..6cde62c4a 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.opt.roslyn.il @@ -499,8 +499,8 @@ { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' '<>9' - .field public static class [mscorlib]System.EventHandler '<>9__23_0' - .field public static class [mscorlib]System.Func`2 '<>9__43_0' + .field public static class [mscorlib]System.EventHandler '<>9__26_0' + .field public static class [mscorlib]System.Func`2 '<>9__46_0' .method private hidebysig specialname rtspecialname static void .cctor() cil managed { @@ -522,17 +522,17 @@ } // end of method '<>c'::.ctor .method assembly hidebysig instance void - 'b__23_0'(object '', + 'b__26_0'(object '', class [mscorlib]System.EventArgs '') cil managed { // Code size 6 (0x6) .maxstack 8 IL_0000: call void [mscorlib]System.Console::WriteLine() IL_0005: ret - } // end of method '<>c'::'b__23_0' + } // end of method '<>c'::'b__26_0' .method assembly hidebysig instance bool - 'b__43_0'(class [mscorlib]System.Globalization.NumberFormatInfo format) cil managed + 'b__46_0'(class [mscorlib]System.Globalization.NumberFormatInfo format) cil managed { // Code size 17 (0x11) .maxstack 8 @@ -542,7 +542,7 @@ IL_000b: call bool [mscorlib]System.String::op_Equality(string, string) IL_0010: ret - } // end of method '<>c'::'b__43_0' + } // end of method '<>c'::'b__46_0' } // end of class '<>c' @@ -688,6 +688,68 @@ IL_0024: ret } // end of method InitializerTests::Test4 + .method public hidebysig static void InvalidIndices(int32 a) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.1 + IL_0009: ldarg.0 + IL_000a: stelem.i4 + IL_000b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0010: ldloc.0 + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0016: ret + } // end of method InitializerTests::InvalidIndices + + .method public hidebysig static void InvalidIndices2(int32 a) cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.1 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.m1 + IL_0009: ldarg.0 + IL_000a: stelem.i4 + IL_000b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0010: ldloc.0 + IL_0011: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0016: ret + } // end of method InitializerTests::InvalidIndices2 + + .method public hidebysig static void IndicesInWrongOrder(int32 a, + int32 b) cil managed + { + // Code size 27 (0x1b) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: ldc.i4.5 + IL_0001: newarr [mscorlib]System.Int32 + IL_0006: stloc.0 + IL_0007: ldloc.0 + IL_0008: ldc.i4.2 + IL_0009: ldarg.1 + IL_000a: stelem.i4 + IL_000b: ldloc.0 + IL_000c: ldc.i4.1 + IL_000d: ldarg.0 + IL_000e: stelem.i4 + IL_000f: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0014: ldloc.0 + IL_0015: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_001a: ret + } // end of method InitializerTests::IndicesInWrongOrder + .method public hidebysig static void CollectionInitializerList() cil managed { // Code size 37 (0x25) @@ -829,18 +891,18 @@ IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/Data::.ctor() IL_0005: stloc.0 IL_0006: ldloc.0 - IL_0007: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__23_0' + IL_0007: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__26_0' IL_000c: dup IL_000d: brtrue.s IL_0026 IL_000f: pop IL_0010: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9' - IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__23_0'(object, + IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__26_0'(object, class [mscorlib]System.EventArgs) IL_001b: newobj instance void [mscorlib]System.EventHandler::.ctor(object, native int) IL_0020: dup - IL_0021: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__23_0' + IL_0021: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__26_0' IL_0026: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/Data::add_TestEvent(class [mscorlib]System.EventHandler) IL_002b: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() IL_0030: ldloc.0 @@ -1303,17 +1365,17 @@ IL_0033: callvirt instance void [mscorlib]System.Globalization.CultureInfo::set_DateTimeFormat(class [mscorlib]System.Globalization.DateTimeFormatInfo) IL_0038: dup IL_0039: ldloc.0 - IL_003a: ldsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__43_0' + IL_003a: ldsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__46_0' IL_003f: dup IL_0040: brtrue.s IL_0059 IL_0042: pop IL_0043: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9' - IL_0048: ldftn instance bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__43_0'(class [mscorlib]System.Globalization.NumberFormatInfo) + IL_0048: ldftn instance bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__46_0'(class [mscorlib]System.Globalization.NumberFormatInfo) IL_004e: newobj instance void class [mscorlib]System.Func`2::.ctor(object, native int) IL_0053: dup - IL_0054: stsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__43_0' + IL_0054: stsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__46_0' IL_0059: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Core]System.Linq.Enumerable::Where(class [mscorlib]System.Collections.Generic.IEnumerable`1, class [mscorlib]System.Func`2) IL_005e: call !!0 [System.Core]System.Linq.Enumerable::First(class [mscorlib]System.Collections.Generic.IEnumerable`1) diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.roslyn.il index 63b2de34e..959e70c3a 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InitializerTests.roslyn.il @@ -526,8 +526,8 @@ { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' '<>9' - .field public static class [mscorlib]System.EventHandler '<>9__23_0' - .field public static class [mscorlib]System.Func`2 '<>9__43_0' + .field public static class [mscorlib]System.EventHandler '<>9__26_0' + .field public static class [mscorlib]System.Func`2 '<>9__46_0' .method private hidebysig specialname rtspecialname static void .cctor() cil managed { @@ -550,7 +550,7 @@ } // end of method '<>c'::.ctor .method assembly hidebysig instance void - 'b__23_0'(object '', + 'b__26_0'(object '', class [mscorlib]System.EventArgs '') cil managed { // Code size 8 (0x8) @@ -559,10 +559,10 @@ IL_0001: call void [mscorlib]System.Console::WriteLine() IL_0006: nop IL_0007: ret - } // end of method '<>c'::'b__23_0' + } // end of method '<>c'::'b__26_0' .method assembly hidebysig instance bool - 'b__43_0'(class [mscorlib]System.Globalization.NumberFormatInfo format) cil managed + 'b__46_0'(class [mscorlib]System.Globalization.NumberFormatInfo format) cil managed { // Code size 17 (0x11) .maxstack 8 @@ -572,7 +572,7 @@ IL_000b: call bool [mscorlib]System.String::op_Equality(string, string) IL_0010: ret - } // end of method '<>c'::'b__43_0' + } // end of method '<>c'::'b__46_0' } // end of class '<>c' @@ -782,6 +782,74 @@ IL_002b: ret } // end of method InitializerTests::Test4 + .method public hidebysig static void InvalidIndices(int32 a) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.1 + IL_000a: ldarg.0 + IL_000b: stelem.i4 + IL_000c: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0011: ldloc.0 + IL_0012: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0017: nop + IL_0018: ret + } // end of method InitializerTests::InvalidIndices + + .method public hidebysig static void InvalidIndices2(int32 a) cil managed + { + // Code size 25 (0x19) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.1 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.m1 + IL_000a: ldarg.0 + IL_000b: stelem.i4 + IL_000c: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0011: ldloc.0 + IL_0012: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_0017: nop + IL_0018: ret + } // end of method InitializerTests::InvalidIndices2 + + .method public hidebysig static void IndicesInWrongOrder(int32 a, + int32 b) cil managed + { + // Code size 29 (0x1d) + .maxstack 3 + .locals init (int32[] V_0) + IL_0000: nop + IL_0001: ldc.i4.5 + IL_0002: newarr [mscorlib]System.Int32 + IL_0007: stloc.0 + IL_0008: ldloc.0 + IL_0009: ldc.i4.2 + IL_000a: ldarg.1 + IL_000b: stelem.i4 + IL_000c: ldloc.0 + IL_000d: ldc.i4.1 + IL_000e: ldarg.0 + IL_000f: stelem.i4 + IL_0010: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() + IL_0015: ldloc.0 + IL_0016: call void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::X(object, + object) + IL_001b: nop + IL_001c: ret + } // end of method InitializerTests::IndicesInWrongOrder + .method public hidebysig static void CollectionInitializerList() cil managed { // Code size 42 (0x2a) @@ -959,18 +1027,18 @@ IL_0001: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/Data::.ctor() IL_0006: stloc.0 IL_0007: ldloc.0 - IL_0008: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__23_0' + IL_0008: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__26_0' IL_000d: dup IL_000e: brtrue.s IL_0027 IL_0010: pop IL_0011: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9' - IL_0016: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__23_0'(object, + IL_0016: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__26_0'(object, class [mscorlib]System.EventArgs) IL_001c: newobj instance void [mscorlib]System.EventHandler::.ctor(object, native int) IL_0021: dup - IL_0022: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__23_0' + IL_0022: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__26_0' IL_0027: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/Data::add_TestEvent(class [mscorlib]System.EventHandler) IL_002c: nop IL_002d: call object ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests::Y() @@ -1525,17 +1593,17 @@ IL_003b: nop IL_003c: dup IL_003d: ldloc.0 - IL_003e: ldsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__43_0' + IL_003e: ldsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__46_0' IL_0043: dup IL_0044: brtrue.s IL_005d IL_0046: pop IL_0047: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9' - IL_004c: ldftn instance bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__43_0'(class [mscorlib]System.Globalization.NumberFormatInfo) + IL_004c: ldftn instance bool ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'b__46_0'(class [mscorlib]System.Globalization.NumberFormatInfo) IL_0052: newobj instance void class [mscorlib]System.Func`2::.ctor(object, native int) IL_0057: dup - IL_0058: stsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__43_0' + IL_0058: stsfld class [mscorlib]System.Func`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.InitializerTests/'<>c'::'<>9__46_0' IL_005d: call class [mscorlib]System.Collections.Generic.IEnumerable`1 [System.Core]System.Linq.Enumerable::Where(class [mscorlib]System.Collections.Generic.IEnumerable`1, class [mscorlib]System.Func`2) IL_0062: call !!0 [System.Core]System.Linq.Enumerable::First(class [mscorlib]System.Collections.Generic.IEnumerable`1) diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.il index 5ff162ea6..79d530431 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly cljdpn4p +.assembly InlineAssignmentTest { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module cljdpn4p.dll -// MVID: {4E91830C-4968-4AA2-B516-7FDA32452515} +.module InlineAssignmentTest.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x006A0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -527,4 +523,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\InlineAssignmentTest.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.opt.il index b6948ebda..265095720 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/InlineAssignmentTest.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly jfxjxuqt +.assembly InlineAssignmentTest.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module jfxjxuqt.dll -// MVID: {862986C8-F9C1-4FF3-8646-A3CA63D29744} +.module InlineAssignmentTest.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x010B0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -428,4 +424,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\InlineAssignmentTest.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.il index b3fc95108..a2f026464 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.18020 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '35ltrsak' +.assembly LiftedOperators { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '35ltrsak.dll' -// MVID: {E2680319-4EDA-4756-B327-523DC92BF0AB} +.module LiftedOperators.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00ED0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -6936,4 +6932,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\LiftedOperators.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.opt.il index 45b7a0d10..281683b11 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/LiftedOperators.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.18020 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly n45w5r1e +.assembly LiftedOperators.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module n45w5r1e.dll -// MVID: {A02D3ECA-E4C6-46ED-A628-8A99594A9C16} +.module LiftedOperators.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02DA0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -6377,4 +6373,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\LiftedOperators.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.il index 77d86c654..6514f1609 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '1c2baaro' +.assembly Lock { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '1c2baaro.dll' -// MVID: {5FC5B58D-AAD7-4436-A58F-6F3D75486C66} +.module Lock.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00C60000 // =============== CLASS MEMBERS DECLARATION =================== @@ -143,4 +139,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Lock.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.mcs.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.mcs.il index 9c5329ebc..22bc5843b 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.mcs.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.mcs.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 2:0:0:0 } -.assembly tmpE10E +.assembly Lock.mcs { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -53,15 +51,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tmpE10E.tmp -// MVID: {0300BC49-B2EF-4506-8B74-DF85DD4F91E4} +.module Lock.mcs.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x00400000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04DB0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -136,4 +132,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Lock.mcs.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.il index 6f30273b4..b29f8b1b3 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly titpuxma +.assembly Lock.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module titpuxma.dll -// MVID: {8B90EB29-A139-4376-848E-C5D4D42952F1} +.module Lock.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02AF0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -119,4 +115,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Lock.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.mcs.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.mcs.il index e0d58c40c..2e3613661 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.mcs.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Lock.opt.mcs.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 2:0:0:0 } -.assembly tmpE3DF +.assembly Lock.opt.mcs { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -53,15 +51,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tmpE3DF.tmp -// MVID: {2EBA312B-EF3B-4364-91A6-0062C2105169} +.module Lock.opt.mcs.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x00400000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03960000 // =============== CLASS MEMBERS DECLARATION =================== @@ -136,4 +132,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Lock.opt.mcs.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.il index 5ead7472c..cae8916bf 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '50bjvac5' +.assembly Loops { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '50bjvac5.dll' -// MVID: {7EA9F0A8-B896-4F84-BCD8-AC7B4D44BBC0} +.module Loops.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03450000 // =============== CLASS MEMBERS DECLARATION =================== @@ -2692,4 +2688,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Loops.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.mcs.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.mcs.il index 3553741a8..33f5364ce 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.mcs.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.mcs.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 3:5:0:0 } -.assembly tmp92BB +.assembly Loops.mcs { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -58,15 +56,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tmp92BB.tmp -// MVID: {C1A55351-8EB8-4535-855C-2DDA0B7B97CF} +.module Loops.mcs.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x00400000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03820000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1943,4 +1939,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Loops.mcs.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.il index 85c9a754c..62ffe1ed9 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly ca3webe1 +.assembly Loops.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module ca3webe1.dll -// MVID: {3674B35A-51F1-4E0A-A67E-D7FEBA11373B} +.module Loops.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02DA0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -2089,4 +2085,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Loops.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.mcs.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.mcs.il index 1621be6cd..3d77509a0 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.mcs.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Loops.opt.mcs.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -15,7 +13,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 3:5:0:0 } -.assembly tmpC964 +.assembly Loops.opt.mcs { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -58,15 +56,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tmpC964.tmp -// MVID: {E309B5C7-312B-4338-9E32-97629EBB582F} +.module Loops.opt.mcs.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x00400000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04B70000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1943,4 +1939,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Loops.opt.mcs.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.il index 392833e8b..ca9d8a12e 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.il @@ -7,7 +7,7 @@ ) .ver 4:0:0:0 } -.assembly c0d101lq +.assembly PInvoke { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 @@ -26,7 +26,6 @@ } .module PInvoke -// MVID: {F608732B-D0A2-45AE-9706-B0B2379F8AAE} .corflags 0x00000001 // ILOnly .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.il index 8da114904..886bdb35c 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.il @@ -7,7 +7,7 @@ ) .ver 4:0:0:0 } -.assembly jfi2am5n +.assembly PInvoke.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 @@ -26,7 +26,6 @@ } .module PInvoke.opt -// MVID: {8A131D15-EAC0-48F2-A958-1AF6CBD25557} .corflags 0x00000001 // ILOnly .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.roslyn.il index 2b17265e9..8ffa77319 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.opt.roslyn.il @@ -29,7 +29,6 @@ } .module PInvoke.opt.roslyn -// MVID: {63CD2985-0EDA-4C6F-91E0-BFDEBA4905D5} .corflags 0x00000001 // ILOnly .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.roslyn.il index 197d32920..fd4a1f821 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PInvoke.roslyn.il @@ -29,7 +29,6 @@ } .module PInvoke.roslyn -// MVID: {86F00A7C-01D7-4EA0-AFE1-EB3A06A0C1FD} .corflags 0x00000001 // ILOnly .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.cs index 92e9a63b9..3f8d59d1f 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.cs @@ -32,11 +32,24 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty } } + [NonSerialized] + private int someField; + public int Value { get; private set; } +#if ROSLYN + public int NotAnAutoProperty => someField; +#else + public int NotAnAutoProperty { + get { + return someField; + } + } +#endif + public event EventHandler AutomaticEvent; [field: NonSerialized] diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.il index d39f70d58..fd4be9f50 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly l2f5cj2d +.assembly PropertiesAndEvents { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module l2f5cj2d.dll -// MVID: {B40A9FBE-DEAE-43DA-970B-68C48E122E20} +.module PropertiesAndEvents.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00DC0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -39,34 +35,34 @@ .class interface abstract auto ansi nested private IBase { .method public hidebysig newslot specialname abstract virtual - instance void add_Event(class [mscorlib]System.Action 'value') cil managed + instance int32 get_Test() cil managed { - } // end of method IBase::add_Event + } // end of method IBase::get_Test .method public hidebysig newslot specialname abstract virtual - instance void remove_Event(class [mscorlib]System.Action 'value') cil managed + instance void set_Test(int32 'value') cil managed { - } // end of method IBase::remove_Event + } // end of method IBase::set_Test .method public hidebysig newslot specialname abstract virtual - instance int32 get_Test() cil managed + instance void add_Event(class [mscorlib]System.Action 'value') cil managed { - } // end of method IBase::get_Test + } // end of method IBase::add_Event .method public hidebysig newslot specialname abstract virtual - instance void set_Test(int32 'value') cil managed + instance void remove_Event(class [mscorlib]System.Action 'value') cil managed { - } // end of method IBase::set_Test + } // end of method IBase::remove_Event .event [mscorlib]System.Action Event { - .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event(class [mscorlib]System.Action) .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event(class [mscorlib]System.Action) + .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event(class [mscorlib]System.Action) } // end of event IBase::Event .property instance int32 Test() { - .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test(int32) .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test(int32) } // end of property IBase::Test } // end of class IBase @@ -75,45 +71,45 @@ implements ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase { .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event(class [mscorlib]System.Action 'value') cil managed + instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event - // Code size 2 (0x2) + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test + // Code size 7 (0x7) .maxstack 8 IL_0000: nop - IL_0001: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event + IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0006: throw + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event(class [mscorlib]System.Action 'value') cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test // Code size 2 (0x2) .maxstack 8 IL_0000: nop IL_0001: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test .method private hidebysig newslot specialname virtual final - instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event(class [mscorlib]System.Action 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test - // Code size 7 (0x7) + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event + // Code size 2 (0x2) .maxstack 8 IL_0000: nop - IL_0001: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0006: throw - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test + IL_0001: ret + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32 'value') cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event(class [mscorlib]System.Action 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event // Code size 2 (0x2) .maxstack 8 IL_0000: nop IL_0001: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event .method public hidebysig specialname rtspecialname instance void .ctor() cil managed @@ -132,11 +128,12 @@ } // end of event Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Event .property instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Test() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() } // end of property Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Test } // end of class Impl + .field private notserialized int32 someField .field private class [mscorlib]System.EventHandler AutomaticEvent .field private notserialized class [mscorlib]System.EventHandler AutomaticEventWithInitializer .field private int32 'k__BackingField' @@ -171,6 +168,22 @@ IL_0007: ret } // end of method PropertiesAndEvents::set_Value + .method public hidebysig specialname instance int32 + get_NotAnAutoProperty() cil managed + { + // Code size 12 (0xc) + .maxstack 1 + .locals init (int32 V_0) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::someField + IL_0007: stloc.0 + IL_0008: br.s IL_000a + + IL_000a: ldloc.0 + IL_000b: ret + } // end of method PropertiesAndEvents::get_NotAnAutoProperty + .method public hidebysig specialname instance void add_AutomaticEvent(class [mscorlib]System.EventHandler 'value') cil managed { @@ -382,8 +395,8 @@ IL_002c: ret } // end of method PropertiesAndEvents::.ctor - .method private hidebysig static void '<.ctor>b__0'(object sender, - class [mscorlib]System.EventArgs e) cil managed + .method private hidebysig static void '<.ctor>b__0'(object param0, + class [mscorlib]System.EventArgs param1) cil managed { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) // Code size 2 (0x2) @@ -394,13 +407,13 @@ .event [mscorlib]System.EventHandler AutomaticEvent { - .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEvent(class [mscorlib]System.EventHandler) .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEvent(class [mscorlib]System.EventHandler) + .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEvent(class [mscorlib]System.EventHandler) } // end of event PropertiesAndEvents::AutomaticEvent .event [mscorlib]System.EventHandler AutomaticEventWithInitializer { - .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) + .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) } // end of event PropertiesAndEvents::AutomaticEventWithInitializer .event [mscorlib]System.EventHandler CustomEvent { @@ -409,13 +422,16 @@ } // end of event PropertiesAndEvents::CustomEvent .property instance int32 Value() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::set_Value(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() } // end of property PropertiesAndEvents::Value + .property instance int32 NotAnAutoProperty() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_NotAnAutoProperty() + } // end of property PropertiesAndEvents::NotAnAutoProperty } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\PropertiesAndEvents.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.il index 340d81bc0..8cf711c57 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly sagvhpmx +.assembly PropertiesAndEvents.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module sagvhpmx.dll -// MVID: {01D434AD-9489-4A19-81AE-3BC2177A09C3} +.module PropertiesAndEvents.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02850000 // =============== CLASS MEMBERS DECLARATION =================== @@ -39,34 +35,34 @@ .class interface abstract auto ansi nested private IBase { .method public hidebysig newslot specialname abstract virtual - instance void add_Event(class [mscorlib]System.Action 'value') cil managed + instance int32 get_Test() cil managed { - } // end of method IBase::add_Event + } // end of method IBase::get_Test .method public hidebysig newslot specialname abstract virtual - instance void remove_Event(class [mscorlib]System.Action 'value') cil managed + instance void set_Test(int32 'value') cil managed { - } // end of method IBase::remove_Event + } // end of method IBase::set_Test .method public hidebysig newslot specialname abstract virtual - instance int32 get_Test() cil managed + instance void add_Event(class [mscorlib]System.Action 'value') cil managed { - } // end of method IBase::get_Test + } // end of method IBase::add_Event .method public hidebysig newslot specialname abstract virtual - instance void set_Test(int32 'value') cil managed + instance void remove_Event(class [mscorlib]System.Action 'value') cil managed { - } // end of method IBase::set_Test + } // end of method IBase::remove_Event .event [mscorlib]System.Action Event { - .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event(class [mscorlib]System.Action) .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event(class [mscorlib]System.Action) + .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event(class [mscorlib]System.Action) } // end of event IBase::Event .property instance int32 Test() { - .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test(int32) .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test() + .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test(int32) } // end of property IBase::Test } // end of class IBase @@ -75,41 +71,41 @@ implements ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase { .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event(class [mscorlib]System.Action 'value') cil managed + instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event - // Code size 1 (0x1) + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test + // Code size 6 (0x6) .maxstack 8 - IL_0000: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event + IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() + IL_0005: throw + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event(class [mscorlib]System.Action 'value') cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test // Code size 1 (0x1) .maxstack 8 IL_0000: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test .method private hidebysig newslot specialname virtual final - instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event(class [mscorlib]System.Action 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::get_Test - // Code size 6 (0x6) + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::add_Event + // Code size 1 (0x1) .maxstack 8 - IL_0000: newobj instance void [mscorlib]System.NotImplementedException::.ctor() - IL_0005: throw - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test + IL_0000: ret + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.add_Event .method private hidebysig newslot specialname virtual final - instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32 'value') cil managed + instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event(class [mscorlib]System.Action 'value') cil managed { - .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::set_Test + .override ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/IBase::remove_Event // Code size 1 (0x1) .maxstack 8 IL_0000: ret - } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test + } // end of method Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.remove_Event .method public hidebysig specialname rtspecialname instance void .ctor() cil managed @@ -128,11 +124,12 @@ } // end of event Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Event .property instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Test() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.set_Test(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.get_Test() } // end of property Impl::ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents.IBase.Test } // end of class Impl + .field private notserialized int32 someField .field private class [mscorlib]System.EventHandler AutomaticEvent .field private notserialized class [mscorlib]System.EventHandler AutomaticEventWithInitializer .field private int32 'k__BackingField' @@ -162,6 +159,16 @@ IL_0007: ret } // end of method PropertiesAndEvents::set_Value + .method public hidebysig specialname instance int32 + get_NotAnAutoProperty() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::someField + IL_0006: ret + } // end of method PropertiesAndEvents::get_NotAnAutoProperty + .method public hidebysig specialname instance void add_AutomaticEvent(class [mscorlib]System.EventHandler 'value') cil managed { @@ -342,8 +349,8 @@ IL_0029: ret } // end of method PropertiesAndEvents::.ctor - .method private hidebysig static void '<.ctor>b__0'(object sender, - class [mscorlib]System.EventArgs e) cil managed + .method private hidebysig static void '<.ctor>b__0'(object param0, + class [mscorlib]System.EventArgs param1) cil managed { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) // Code size 1 (0x1) @@ -353,13 +360,13 @@ .event [mscorlib]System.EventHandler AutomaticEvent { - .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEvent(class [mscorlib]System.EventHandler) .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEvent(class [mscorlib]System.EventHandler) + .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEvent(class [mscorlib]System.EventHandler) } // end of event PropertiesAndEvents::AutomaticEvent .event [mscorlib]System.EventHandler AutomaticEventWithInitializer { - .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) .removeon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::remove_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) + .addon instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::add_AutomaticEventWithInitializer(class [mscorlib]System.EventHandler) } // end of event PropertiesAndEvents::AutomaticEventWithInitializer .event [mscorlib]System.EventHandler CustomEvent { @@ -368,13 +375,16 @@ } // end of event PropertiesAndEvents::CustomEvent .property instance int32 Value() { - .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::set_Value(int32) + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() } // end of property PropertiesAndEvents::Value + .property instance int32 NotAnAutoProperty() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_NotAnAutoProperty() + } // end of property PropertiesAndEvents::NotAnAutoProperty } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\PropertiesAndEvents.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.roslyn.il index d7abdc9ab..76da51a5b 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.opt.roslyn.il @@ -140,7 +140,7 @@ { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c' '<>9' - .field public static class [mscorlib]System.EventHandler '<>9__15_0' + .field public static class [mscorlib]System.EventHandler '<>9__18_0' .method private hidebysig specialname rtspecialname static void .cctor() cil managed { @@ -162,16 +162,17 @@ } // end of method '<>c'::.ctor .method assembly hidebysig instance void - '<.ctor>b__15_0'(object '', + '<.ctor>b__18_0'(object '', class [mscorlib]System.EventArgs '') cil managed { // Code size 1 (0x1) .maxstack 8 IL_0000: ret - } // end of method '<>c'::'<.ctor>b__15_0' + } // end of method '<>c'::'<.ctor>b__18_0' } // end of class '<>c' + .field private notserialized int32 someField .field private int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field private class [mscorlib]System.EventHandler AutomaticEvent @@ -201,6 +202,16 @@ IL_0007: ret } // end of method PropertiesAndEvents::set_Value + .method public hidebysig specialname instance int32 + get_NotAnAutoProperty() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::someField + IL_0006: ret + } // end of method PropertiesAndEvents::get_NotAnAutoProperty + .method public hidebysig specialname instance void add_AutomaticEvent(class [mscorlib]System.EventHandler 'value') cil managed { @@ -369,18 +380,18 @@ // Code size 44 (0x2c) .maxstack 8 IL_0000: ldarg.0 - IL_0001: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__15_0' + IL_0001: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__18_0' IL_0006: dup IL_0007: brtrue.s IL_0020 IL_0009: pop IL_000a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9' - IL_000f: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<.ctor>b__15_0'(object, + IL_000f: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<.ctor>b__18_0'(object, class [mscorlib]System.EventArgs) IL_0015: newobj instance void [mscorlib]System.EventHandler::.ctor(object, native int) IL_001a: dup - IL_001b: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__15_0' + IL_001b: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__18_0' IL_0020: stfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::AutomaticEventWithInitializer IL_0025: ldarg.0 IL_0026: call instance void [mscorlib]System.Object::.ctor() @@ -407,6 +418,10 @@ .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::set_Value(int32) } // end of property PropertiesAndEvents::Value + .property instance int32 NotAnAutoProperty() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_NotAnAutoProperty() + } // end of property PropertiesAndEvents::NotAnAutoProperty } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.roslyn.il index 63fe7a5d1..d63dc5872 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/PropertiesAndEvents.roslyn.il @@ -145,7 +145,7 @@ { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c' '<>9' - .field public static class [mscorlib]System.EventHandler '<>9__15_0' + .field public static class [mscorlib]System.EventHandler '<>9__18_0' .method private hidebysig specialname rtspecialname static void .cctor() cil managed { @@ -168,17 +168,18 @@ } // end of method '<>c'::.ctor .method assembly hidebysig instance void - '<.ctor>b__15_0'(object '', + '<.ctor>b__18_0'(object '', class [mscorlib]System.EventArgs '') cil managed { // Code size 2 (0x2) .maxstack 8 IL_0000: nop IL_0001: ret - } // end of method '<>c'::'<.ctor>b__15_0' + } // end of method '<>c'::'<.ctor>b__18_0' } // end of class '<>c' + .field private notserialized int32 someField .field private int32 'k__BackingField' .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .custom instance void [mscorlib]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggerBrowsableState) = ( 01 00 00 00 00 00 00 00 ) @@ -211,6 +212,16 @@ IL_0007: ret } // end of method PropertiesAndEvents::set_Value + .method public hidebysig specialname instance int32 + get_NotAnAutoProperty() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldfld int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::someField + IL_0006: ret + } // end of method PropertiesAndEvents::get_NotAnAutoProperty + .method public hidebysig specialname instance void add_AutomaticEvent(class [mscorlib]System.EventHandler 'value') cil managed { @@ -383,18 +394,18 @@ // Code size 45 (0x2d) .maxstack 8 IL_0000: ldarg.0 - IL_0001: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__15_0' + IL_0001: ldsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__18_0' IL_0006: dup IL_0007: brtrue.s IL_0020 IL_0009: pop IL_000a: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9' - IL_000f: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<.ctor>b__15_0'(object, + IL_000f: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<.ctor>b__18_0'(object, class [mscorlib]System.EventArgs) IL_0015: newobj instance void [mscorlib]System.EventHandler::.ctor(object, native int) IL_001a: dup - IL_001b: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__15_0' + IL_001b: stsfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents/'<>c'::'<>9__18_0' IL_0020: stfld class [mscorlib]System.EventHandler ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::AutomaticEventWithInitializer IL_0025: ldarg.0 IL_0026: call instance void [mscorlib]System.Object::.ctor() @@ -422,6 +433,10 @@ .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_Value() .set instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::set_Value(int32) } // end of property PropertiesAndEvents::Value + .property instance int32 NotAnAutoProperty() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents::get_NotAnAutoProperty() + } // end of property PropertiesAndEvents::NotAnAutoProperty } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.PropertiesAndEvents diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.il index 912180bb9..970c9135e 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly bqtfnoxz +.assembly ShortCircuit { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module bqtfnoxz.dll -// MVID: {E41D831E-089A-4F86-AA5D-FD2CB6D7C452} +.module ShortCircuit.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03120000 // =============== CLASS MEMBERS DECLARATION =================== @@ -636,4 +632,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ShortCircuit.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.opt.il index afa808e96..c4b693be9 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/ShortCircuit.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '4yyrmwig' +.assembly ShortCircuit.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '4yyrmwig.dll' -// MVID: {A53FB590-72B6-46AB-809D-9F6F92B64475} +.module ShortCircuit.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x015D0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -464,4 +460,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\ShortCircuit.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.il index daad6b12d..476dbee82 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly eo05gpu0 +.assembly Switch { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module eo05gpu0.dll -// MVID: {9D56DD8F-56CC-4AA5-939D-F5DC041F1927} +.module Switch.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04BA0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -880,7 +876,7 @@ IL_0015: brfalse IL_00e9 IL_001a: volatile. - IL_001c: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000d-1' + IL_001c: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_0021: brtrue.s IL_0084 IL_0023: ldc.i4.7 @@ -921,9 +917,9 @@ IL_0078: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_007d: volatile. - IL_007f: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000d-1' + IL_007f: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_0084: volatile. - IL_0086: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000d-1' + IL_0086: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_008b: ldloc.1 IL_008c: ldloca.s V_2 IL_008e: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -995,7 +991,7 @@ IL_0013: brfalse IL_0158 IL_0018: volatile. - IL_001a: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000e-1' + IL_001a: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_001f: brtrue IL_00b8 IL_0024: ldc.i4.s 11 @@ -1056,9 +1052,9 @@ IL_00ac: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_00b1: volatile. - IL_00b3: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000e-1' + IL_00b3: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_00b8: volatile. - IL_00ba: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x600000e-1' + IL_00ba: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_00bf: ldloc.1 IL_00c0: ldloca.s V_2 IL_00c2: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -1346,7 +1342,7 @@ IL_003b: brfalse IL_012c IL_0040: volatile. - IL_0042: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x6000013-1' + IL_0042: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_0047: brtrue.s IL_009e IL_0049: ldc.i4.6 @@ -1382,9 +1378,9 @@ IL_0092: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_0097: volatile. - IL_0099: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x6000013-1' + IL_0099: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_009e: volatile. - IL_00a0: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}'::'$$method0x6000013-1' + IL_00a0: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_00a5: ldloc.s V_5 IL_00a7: ldloca.s V_6 IL_00a9: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -1611,17 +1607,16 @@ } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch -.class private auto ansi '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}' +.class private auto ansi '' extends [mscorlib]System.Object { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x600000d-1' .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x600000e-1' .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x6000013-1' -} // end of class '{9D56DD8F-56CC-4AA5-939D-F5DC041F1927}' +} // end of class '' // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Switch.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.opt.il index d039e7256..719b11561 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Switch.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '1cqmq4ya' +.assembly Switch.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '1cqmq4ya.dll' -// MVID: {F6D6A0F8-249B-42E0-A06F-7A75134FD239} +.module Switch.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x05550000 // =============== CLASS MEMBERS DECLARATION =================== @@ -749,7 +745,7 @@ IL_0013: brfalse IL_00db IL_0018: volatile. - IL_001a: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000d-1' + IL_001a: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_001f: brtrue.s IL_0082 IL_0021: ldc.i4.7 @@ -790,9 +786,9 @@ IL_0076: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_007b: volatile. - IL_007d: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000d-1' + IL_007d: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_0082: volatile. - IL_0084: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000d-1' + IL_0084: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000d-1' IL_0089: ldloc.0 IL_008a: ldloca.s V_1 IL_008c: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -850,7 +846,7 @@ IL_0011: brfalse IL_013d IL_0016: volatile. - IL_0018: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000e-1' + IL_0018: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_001d: brtrue IL_00b6 IL_0022: ldc.i4.s 11 @@ -911,9 +907,9 @@ IL_00aa: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_00af: volatile. - IL_00b1: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000e-1' + IL_00b1: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_00b6: volatile. - IL_00b8: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x600000e-1' + IL_00b8: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x600000e-1' IL_00bd: ldloc.0 IL_00be: ldloca.s V_1 IL_00c0: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -1139,7 +1135,7 @@ IL_0037: brfalse IL_011f IL_003c: volatile. - IL_003e: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x6000013-1' + IL_003e: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_0043: brtrue.s IL_009a IL_0045: ldc.i4.6 @@ -1175,9 +1171,9 @@ IL_008e: call instance void class [mscorlib]System.Collections.Generic.Dictionary`2::Add(!0, !1) IL_0093: volatile. - IL_0095: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x6000013-1' + IL_0095: stsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_009a: volatile. - IL_009c: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}'::'$$method0x6000013-1' + IL_009c: ldsfld class [mscorlib]System.Collections.Generic.Dictionary`2 ''::'$$method0x6000013-1' IL_00a1: ldloc.s V_5 IL_00a3: ldloca.s V_6 IL_00a5: call instance bool class [mscorlib]System.Collections.Generic.Dictionary`2::TryGetValue(!0, @@ -1371,17 +1367,16 @@ } // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.Switch -.class private auto ansi '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}' +.class private auto ansi '' extends [mscorlib]System.Object { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x600000d-1' .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x600000e-1' .field static assembly class [mscorlib]System.Collections.Generic.Dictionary`2 '$$method0x6000013-1' -} // end of class '{F6D6A0F8-249B-42E0-A06F-7A75134FD239}' +} // end of class '' // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\Switch.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.cs new file mode 100644 index 000000000..7796fe88c --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.cs @@ -0,0 +1,100 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty +{ + public class TupleTests + { + private abstract class OverloadResolution + { + public abstract void M1((long, long) a); + public abstract void M1(object a); + + public void UseM1((int, int) a) + { + // M1(a); TODO: tuple conversion transform + // Cast is required to avoid the overload usable via tuple conversion: + M1((object)a); + } + } + + public ValueTuple VT0; + public ValueTuple VT1; + public ValueTuple VT7EmptyRest; + + public (int, uint) Unnamed2; + public (int, int, int) Unnamed3; + public (int, int, int, int) Unnamed4; + public (int, int, int, int, int) Unnamed5; + public (int, int, int, int, int, int) Unnamed6; + public (int, int, int, int, int, int, int) Unnamed7; + public (int, int, int, int, int, int, int, int) Unnamed8; + + public (int a, uint b) Named2; + public (int a, uint b)[] Named2Array; + public (int a, int b, int c, int d, int e, int f, int g, int h) Named8; + + public (int, int a, int, int b, int) PartiallyNamed; + + public ((int a, int b) x, (int, int) y, (int c, int d) z) Nested1; + public ((object a, dynamic b), dynamic, (dynamic c, object d)) Nested2; + public (ValueTuple a, (int x1, int x2), ValueTuple b, (int y1, int y2), (int, int) c) Nested3; + public (int a, int b, int c, int d, int e, int f, int g, int h, (int i, int j)) Nested4; + + public Dictionary<(int a, string b), (string c, int d)> TupleDict; + + public int VT1Member => VT1.Item1; + public int AccessUnnamed8 => Unnamed8.Item8; + public int AccessNamed8 => Named8.h; + public int AccessPartiallyNamed => PartiallyNamed.a + PartiallyNamed.Item3; + + public ValueTuple NewTuple1 => new ValueTuple(1); + public (int a, int b) NewTuple2 => (1, 2); + public object BoxedTuple10 => (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); + + public (uint, int) SwapUnnamed => (Unnamed2.Item2, Unnamed2.Item1); + public (uint, int) SwapNamed2 => (Named2.b, Named2.a); + + public int TupleHash => (1, 2, 3).GetHashCode(); + public int TupleHash2 => Named2.GetHashCode(); + + public (int, int) AccessRest => (1, 2, 3, 4, 5, 6, 7, 8, 9).Rest; + + public (string, object, Action) TargetTyping => (null, 1, delegate { + }); + + public object NotTargetTyping => ((string)null, (object)1, (Action)delegate { + }); + + public void UseDict() + { + if (TupleDict.Count > 10) { + TupleDict.Clear(); + } + // TODO: it would be nice if we could infer the name 'c' for the local + string item = TupleDict[(1, "abc")].c; + Console.WriteLine(item); + Console.WriteLine(item); + Console.WriteLine(TupleDict.Values.ToList().First().d); + } + } +} diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.opt.roslyn.il new file mode 100644 index 000000000..f5993535a --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.opt.roslyn.il @@ -0,0 +1,519 @@ + + + + +// Metadata version: v4.0.30319 +.assembly extern mscorlib +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 4:0:0:0 +} +.assembly extern System.Core +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 4:0:0:0 +} +.assembly TupleTests +{ + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx + 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. + + // --- The following custom attribute is added automatically, do not uncomment ------- + // .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 02 00 00 00 00 00 ) + + .permissionset reqmin + = {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}} + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.module TupleTests.dll +.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) +.imagebase 0x10000000 +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 // WINDOWS_CUI +.corflags 0x00000001 // ILONLY + + +// =============== CLASS MEMBERS DECLARATION =================== + +.class public auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests + extends [mscorlib]System.Object +{ + .class abstract auto ansi nested private beforefieldinit OverloadResolution + extends [mscorlib]System.Object + { + .method public hidebysig newslot abstract virtual + instance void M1(valuetype [mscorlib]System.ValueTuple`2 a) cil managed + { + } // end of method OverloadResolution::M1 + + .method public hidebysig newslot abstract virtual + instance void M1(object a) cil managed + { + } // end of method OverloadResolution::M1 + + .method public hidebysig instance void + UseM1(valuetype [mscorlib]System.ValueTuple`2 a) cil managed + { + // Code size 13 (0xd) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldarg.1 + IL_0002: box valuetype [mscorlib]System.ValueTuple`2 + IL_0007: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/OverloadResolution::M1(object) + IL_000c: ret + } // end of method OverloadResolution::UseM1 + + .method family hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method OverloadResolution::.ctor + + } // end of class OverloadResolution + + .class auto ansi serializable sealed nested private beforefieldinit '<>c' + extends [mscorlib]System.Object + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' '<>9' + .field public static class [mscorlib]System.Action '<>9__45_0' + .field public static class [mscorlib]System.Action '<>9__47_0' + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::.ctor() + IL_0005: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_000a: ret + } // end of method '<>c'::.cctor + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method '<>c'::.ctor + + .method assembly hidebysig instance void + 'b__45_0'() cil managed + { + // Code size 1 (0x1) + .maxstack 8 + IL_0000: ret + } // end of method '<>c'::'b__45_0' + + .method assembly hidebysig instance void + 'b__47_0'() cil managed + { + // Code size 1 (0x1) + .maxstack 8 + IL_0000: ret + } // end of method '<>c'::'b__47_0' + + } // end of class '<>c' + + .field public valuetype [mscorlib]System.ValueTuple VT0 + .field public valuetype [mscorlib]System.ValueTuple`1 VT1 + .field public valuetype [mscorlib]System.ValueTuple`8 VT7EmptyRest + .field public valuetype [mscorlib]System.ValueTuple`2 Unnamed2 + .field public valuetype [mscorlib]System.ValueTuple`3 Unnamed3 + .field public valuetype [mscorlib]System.ValueTuple`4 Unnamed4 + .field public valuetype [mscorlib]System.ValueTuple`5 Unnamed5 + .field public valuetype [mscorlib]System.ValueTuple`6 Unnamed6 + .field public valuetype [mscorlib]System.ValueTuple`7 Unnamed7 + .field public valuetype [mscorlib]System.ValueTuple`8> Unnamed8 + .field public valuetype [mscorlib]System.ValueTuple`2 Named2 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .field public valuetype [mscorlib]System.ValueTuple`2[] Named2Array + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .field public valuetype [mscorlib]System.ValueTuple`8> Named8 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 09 00 00 00 01 61 01 62 01 63 01 64 01 65 // .......a.b.c.d.e + 01 66 01 67 01 68 FF 00 00 ) // .f.g.h... + .field public valuetype [mscorlib]System.ValueTuple`5 PartiallyNamed + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 05 00 00 00 FF 01 61 FF 01 62 FF 00 00 ) // ........a..b... + .field public valuetype [mscorlib]System.ValueTuple`3,valuetype [mscorlib]System.ValueTuple`2,valuetype [mscorlib]System.ValueTuple`2> Nested1 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 09 00 00 00 01 78 01 79 01 7A 01 61 01 62 // .......x.y.z.a.b + FF FF 01 63 01 64 00 00 ) // ...c.d.. + .field public valuetype [mscorlib]System.ValueTuple`3,object,valuetype [mscorlib]System.ValueTuple`2> Nested2 + .custom instance void [System.Core]System.Runtime.CompilerServices.DynamicAttribute::.ctor(bool[]) = ( 01 00 08 00 00 00 00 00 00 01 01 00 01 00 00 00 ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 07 00 00 00 FF FF FF 01 61 01 62 01 63 01 // ..........a.b.c. + 64 00 00 ) // d.. + .field public valuetype [mscorlib]System.ValueTuple`5,valuetype [mscorlib]System.ValueTuple`1,valuetype [mscorlib]System.ValueTuple`2,valuetype [mscorlib]System.ValueTuple`2> Nested3 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 0C 00 00 00 01 61 FF 01 62 FF 01 63 02 78 // .......a..b..c.x + 31 02 78 32 FF 02 79 31 02 79 32 FF FF 00 00 ) // 1.x2..y1.y2.... + .field public valuetype [mscorlib]System.ValueTuple`8>> Nested4 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 0D 00 00 00 01 61 01 62 01 63 01 64 01 65 // .......a.b.c.d.e + 01 66 01 67 01 68 FF FF FF 01 69 01 6A 00 00 ) // .f.g.h....i.j.. + .field public class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> TupleDict + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 04 00 00 00 01 61 01 62 01 63 01 64 00 00 ) // .......a.b.c.d.. + .method public hidebysig specialname instance int32 + get_VT1Member() cil managed + { + // Code size 12 (0xc) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`1 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::VT1 + IL_0006: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_000b: ret + } // end of method TupleTests::get_VT1Member + + .method public hidebysig specialname instance int32 + get_AccessUnnamed8() cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`8> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed8 + IL_0006: ldflda !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_000b: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_0010: ret + } // end of method TupleTests::get_AccessUnnamed8 + + .method public hidebysig specialname instance int32 + get_AccessNamed8() cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`8> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named8 + IL_0006: ldflda !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_000b: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_0010: ret + } // end of method TupleTests::get_AccessNamed8 + + .method public hidebysig specialname instance int32 + get_AccessPartiallyNamed() cil managed + { + // Code size 24 (0x18) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`5 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::PartiallyNamed + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`5::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`5 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::PartiallyNamed + IL_0011: ldfld !2 valuetype [mscorlib]System.ValueTuple`5::Item3 + IL_0016: add + IL_0017: ret + } // end of method TupleTests::get_AccessPartiallyNamed + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`1 + get_NewTuple1() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: newobj instance void valuetype [mscorlib]System.ValueTuple`1::.ctor(!0) + IL_0006: ret + } // end of method TupleTests::get_NewTuple1 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_NewTuple2() cil managed + { + .param [0] + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_0007: ret + } // end of method TupleTests::get_NewTuple2 + + .method public hidebysig specialname instance object + get_BoxedTuple10() cil managed + { + // Code size 28 (0x1c) + .maxstack 10 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: ldc.i4.4 + IL_0004: ldc.i4.5 + IL_0005: ldc.i4.6 + IL_0006: ldc.i4.7 + IL_0007: ldc.i4.8 + IL_0008: ldc.i4.s 9 + IL_000a: ldc.i4.s 10 + IL_000c: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_0011: newobj instance void valuetype [mscorlib]System.ValueTuple`8>::.ctor(!0, + !1, + !2, + !3, + !4, + !5, + !6, + !7) + IL_0016: box valuetype [mscorlib]System.ValueTuple`8> + IL_001b: ret + } // end of method TupleTests::get_BoxedTuple10 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_SwapUnnamed() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed2 + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed2 + IL_0011: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_0016: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_001b: ret + } // end of method TupleTests::get_SwapUnnamed + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_SwapNamed2() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0011: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_0016: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_001b: ret + } // end of method TupleTests::get_SwapNamed2 + + .method public hidebysig specialname instance int32 + get_TupleHash() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (valuetype [mscorlib]System.ValueTuple`3 V_0) + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_0008: stloc.0 + IL_0009: ldloca.s V_0 + IL_000b: constrained. valuetype [mscorlib]System.ValueTuple`3 + IL_0011: callvirt instance int32 [mscorlib]System.Object::GetHashCode() + IL_0016: ret + } // end of method TupleTests::get_TupleHash + + .method public hidebysig specialname instance int32 + get_TupleHash2() cil managed + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0006: constrained. valuetype [mscorlib]System.ValueTuple`2 + IL_000c: callvirt instance int32 [mscorlib]System.Object::GetHashCode() + IL_0011: ret + } // end of method TupleTests::get_TupleHash2 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_AccessRest() cil managed + { + // Code size 26 (0x1a) + .maxstack 9 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: ldc.i4.4 + IL_0004: ldc.i4.5 + IL_0005: ldc.i4.6 + IL_0006: ldc.i4.7 + IL_0007: ldc.i4.8 + IL_0008: ldc.i4.s 9 + IL_000a: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_000f: newobj instance void valuetype [mscorlib]System.ValueTuple`8>::.ctor(!0, + !1, + !2, + !3, + !4, + !5, + !6, + !7) + IL_0014: ldfld !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_0019: ret + } // end of method TupleTests::get_AccessRest + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`3 + get_TargetTyping() cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldnull + IL_0001: ldc.i4.1 + IL_0002: box [mscorlib]System.Int32 + IL_0007: ldsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__45_0' + IL_000c: dup + IL_000d: brtrue.s IL_0026 + + IL_000f: pop + IL_0010: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'b__45_0'() + IL_001b: newobj instance void [mscorlib]System.Action::.ctor(object, + native int) + IL_0020: dup + IL_0021: stsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__45_0' + IL_0026: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_002b: ret + } // end of method TupleTests::get_TargetTyping + + .method public hidebysig specialname instance object + get_NotTargetTyping() cil managed + { + // Code size 49 (0x31) + .maxstack 8 + IL_0000: ldnull + IL_0001: ldc.i4.1 + IL_0002: box [mscorlib]System.Int32 + IL_0007: ldsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__47_0' + IL_000c: dup + IL_000d: brtrue.s IL_0026 + + IL_000f: pop + IL_0010: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'b__47_0'() + IL_001b: newobj instance void [mscorlib]System.Action::.ctor(object, + native int) + IL_0020: dup + IL_0021: stsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__47_0' + IL_0026: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_002b: box valuetype [mscorlib]System.ValueTuple`3 + IL_0030: ret + } // end of method TupleTests::get_NotTargetTyping + + .method public hidebysig instance void + UseDict() cil managed + { + // Code size 96 (0x60) + .maxstack 3 + IL_0000: ldarg.0 + IL_0001: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0006: callvirt instance int32 class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Count() + IL_000b: ldc.i4.s 10 + IL_000d: ble.s IL_001a + + IL_000f: ldarg.0 + IL_0010: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0015: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::Clear() + IL_001a: ldarg.0 + IL_001b: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0020: ldc.i4.1 + IL_0021: ldstr "abc" + IL_0026: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_002b: callvirt instance !1 class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Item(!0) + IL_0030: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_0035: dup + IL_0036: call void [mscorlib]System.Console::WriteLine(string) + IL_003b: call void [mscorlib]System.Console::WriteLine(string) + IL_0040: ldarg.0 + IL_0041: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0046: callvirt instance class [mscorlib]System.Collections.Generic.Dictionary`2/ValueCollection class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Values() + IL_004b: call class [mscorlib]System.Collections.Generic.List`1 [System.Core]System.Linq.Enumerable::ToList>(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_0050: call !!0 [System.Core]System.Linq.Enumerable::First>(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_0055: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_005a: call void [mscorlib]System.Console::WriteLine(int32) + IL_005f: ret + } // end of method TupleTests::UseDict + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: ret + } // end of method TupleTests::.ctor + + .property instance int32 VT1Member() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_VT1Member() + } // end of property TupleTests::VT1Member + .property instance int32 AccessUnnamed8() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessUnnamed8() + } // end of property TupleTests::AccessUnnamed8 + .property instance int32 AccessNamed8() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessNamed8() + } // end of property TupleTests::AccessNamed8 + .property instance int32 AccessPartiallyNamed() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessPartiallyNamed() + } // end of property TupleTests::AccessPartiallyNamed + .property instance valuetype [mscorlib]System.ValueTuple`1 + NewTuple1() + { + .get instance valuetype [mscorlib]System.ValueTuple`1 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NewTuple1() + } // end of property TupleTests::NewTuple1 + .property instance valuetype [mscorlib]System.ValueTuple`2 + NewTuple2() + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NewTuple2() + } // end of property TupleTests::NewTuple2 + .property instance object BoxedTuple10() + { + .get instance object ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_BoxedTuple10() + } // end of property TupleTests::BoxedTuple10 + .property instance valuetype [mscorlib]System.ValueTuple`2 + SwapUnnamed() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_SwapUnnamed() + } // end of property TupleTests::SwapUnnamed + .property instance valuetype [mscorlib]System.ValueTuple`2 + SwapNamed2() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_SwapNamed2() + } // end of property TupleTests::SwapNamed2 + .property instance int32 TupleHash() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TupleHash() + } // end of property TupleTests::TupleHash + .property instance int32 TupleHash2() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TupleHash2() + } // end of property TupleTests::TupleHash2 + .property instance valuetype [mscorlib]System.ValueTuple`2 + AccessRest() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessRest() + } // end of property TupleTests::AccessRest + .property instance valuetype [mscorlib]System.ValueTuple`3 + TargetTyping() + { + .get instance valuetype [mscorlib]System.ValueTuple`3 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TargetTyping() + } // end of property TupleTests::TargetTyping + .property instance object NotTargetTyping() + { + .get instance object ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NotTargetTyping() + } // end of property TupleTests::NotTargetTyping +} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests + + +// ============================================================= + +// *********** DISASSEMBLY COMPLETE *********************** diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.roslyn.il new file mode 100644 index 000000000..04c5511ba --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TupleTests.roslyn.il @@ -0,0 +1,540 @@ + + + + +// Metadata version: v4.0.30319 +.assembly extern mscorlib +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 4:0:0:0 +} +.assembly extern System.Core +{ + .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. + .ver 4:0:0:0 +} +.assembly TupleTests +{ + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx + 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. + + // --- The following custom attribute is added automatically, do not uncomment ------- + // .custom instance void [mscorlib]System.Diagnostics.DebuggableAttribute::.ctor(valuetype [mscorlib]System.Diagnostics.DebuggableAttribute/DebuggingModes) = ( 01 00 07 01 00 00 00 00 ) + + .permissionset reqmin + = {[mscorlib]System.Security.Permissions.SecurityPermissionAttribute = {property bool 'SkipVerification' = bool(true)}} + .hash algorithm 0x00008004 + .ver 0:0:0:0 +} +.module TupleTests.dll +.custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) +.imagebase 0x10000000 +.file alignment 0x00000200 +.stackreserve 0x00100000 +.subsystem 0x0003 // WINDOWS_CUI +.corflags 0x00000001 // ILONLY + + +// =============== CLASS MEMBERS DECLARATION =================== + +.class public auto ansi beforefieldinit ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests + extends [mscorlib]System.Object +{ + .class abstract auto ansi nested private beforefieldinit OverloadResolution + extends [mscorlib]System.Object + { + .method public hidebysig newslot abstract virtual + instance void M1(valuetype [mscorlib]System.ValueTuple`2 a) cil managed + { + } // end of method OverloadResolution::M1 + + .method public hidebysig newslot abstract virtual + instance void M1(object a) cil managed + { + } // end of method OverloadResolution::M1 + + .method public hidebysig instance void + UseM1(valuetype [mscorlib]System.ValueTuple`2 a) cil managed + { + // Code size 15 (0xf) + .maxstack 8 + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldarg.1 + IL_0003: box valuetype [mscorlib]System.ValueTuple`2 + IL_0008: callvirt instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/OverloadResolution::M1(object) + IL_000d: nop + IL_000e: ret + } // end of method OverloadResolution::UseM1 + + .method family hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: nop + IL_0007: ret + } // end of method OverloadResolution::.ctor + + } // end of class OverloadResolution + + .class auto ansi serializable sealed nested private beforefieldinit '<>c' + extends [mscorlib]System.Object + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) + .field public static initonly class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' '<>9' + .field public static class [mscorlib]System.Action '<>9__45_0' + .field public static class [mscorlib]System.Action '<>9__47_0' + .method private hidebysig specialname rtspecialname static + void .cctor() cil managed + { + // Code size 11 (0xb) + .maxstack 8 + IL_0000: newobj instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::.ctor() + IL_0005: stsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_000a: ret + } // end of method '<>c'::.cctor + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: nop + IL_0007: ret + } // end of method '<>c'::.ctor + + .method assembly hidebysig instance void + 'b__45_0'() cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: nop + IL_0001: ret + } // end of method '<>c'::'b__45_0' + + .method assembly hidebysig instance void + 'b__47_0'() cil managed + { + // Code size 2 (0x2) + .maxstack 8 + IL_0000: nop + IL_0001: ret + } // end of method '<>c'::'b__47_0' + + } // end of class '<>c' + + .field public valuetype [mscorlib]System.ValueTuple VT0 + .field public valuetype [mscorlib]System.ValueTuple`1 VT1 + .field public valuetype [mscorlib]System.ValueTuple`8 VT7EmptyRest + .field public valuetype [mscorlib]System.ValueTuple`2 Unnamed2 + .field public valuetype [mscorlib]System.ValueTuple`3 Unnamed3 + .field public valuetype [mscorlib]System.ValueTuple`4 Unnamed4 + .field public valuetype [mscorlib]System.ValueTuple`5 Unnamed5 + .field public valuetype [mscorlib]System.ValueTuple`6 Unnamed6 + .field public valuetype [mscorlib]System.ValueTuple`7 Unnamed7 + .field public valuetype [mscorlib]System.ValueTuple`8> Unnamed8 + .field public valuetype [mscorlib]System.ValueTuple`2 Named2 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .field public valuetype [mscorlib]System.ValueTuple`2[] Named2Array + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .field public valuetype [mscorlib]System.ValueTuple`8> Named8 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 09 00 00 00 01 61 01 62 01 63 01 64 01 65 // .......a.b.c.d.e + 01 66 01 67 01 68 FF 00 00 ) // .f.g.h... + .field public valuetype [mscorlib]System.ValueTuple`5 PartiallyNamed + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 05 00 00 00 FF 01 61 FF 01 62 FF 00 00 ) // ........a..b... + .field public valuetype [mscorlib]System.ValueTuple`3,valuetype [mscorlib]System.ValueTuple`2,valuetype [mscorlib]System.ValueTuple`2> Nested1 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 09 00 00 00 01 78 01 79 01 7A 01 61 01 62 // .......x.y.z.a.b + FF FF 01 63 01 64 00 00 ) // ...c.d.. + .field public valuetype [mscorlib]System.ValueTuple`3,object,valuetype [mscorlib]System.ValueTuple`2> Nested2 + .custom instance void [System.Core]System.Runtime.CompilerServices.DynamicAttribute::.ctor(bool[]) = ( 01 00 08 00 00 00 00 00 00 01 01 00 01 00 00 00 ) + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 07 00 00 00 FF FF FF 01 61 01 62 01 63 01 // ..........a.b.c. + 64 00 00 ) // d.. + .field public valuetype [mscorlib]System.ValueTuple`5,valuetype [mscorlib]System.ValueTuple`1,valuetype [mscorlib]System.ValueTuple`2,valuetype [mscorlib]System.ValueTuple`2> Nested3 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 0C 00 00 00 01 61 FF 01 62 FF 01 63 02 78 // .......a..b..c.x + 31 02 78 32 FF 02 79 31 02 79 32 FF FF 00 00 ) // 1.x2..y1.y2.... + .field public valuetype [mscorlib]System.ValueTuple`8>> Nested4 + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 0D 00 00 00 01 61 01 62 01 63 01 64 01 65 // .......a.b.c.d.e + 01 66 01 67 01 68 FF FF FF 01 69 01 6A 00 00 ) // .f.g.h....i.j.. + .field public class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> TupleDict + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 04 00 00 00 01 61 01 62 01 63 01 64 00 00 ) // .......a.b.c.d.. + .method public hidebysig specialname instance int32 + get_VT1Member() cil managed + { + // Code size 12 (0xc) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`1 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::VT1 + IL_0006: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_000b: ret + } // end of method TupleTests::get_VT1Member + + .method public hidebysig specialname instance int32 + get_AccessUnnamed8() cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`8> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed8 + IL_0006: ldflda !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_000b: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_0010: ret + } // end of method TupleTests::get_AccessUnnamed8 + + .method public hidebysig specialname instance int32 + get_AccessNamed8() cil managed + { + // Code size 17 (0x11) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`8> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named8 + IL_0006: ldflda !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_000b: ldfld !0 valuetype [mscorlib]System.ValueTuple`1::Item1 + IL_0010: ret + } // end of method TupleTests::get_AccessNamed8 + + .method public hidebysig specialname instance int32 + get_AccessPartiallyNamed() cil managed + { + // Code size 24 (0x18) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`5 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::PartiallyNamed + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`5::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`5 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::PartiallyNamed + IL_0011: ldfld !2 valuetype [mscorlib]System.ValueTuple`5::Item3 + IL_0016: add + IL_0017: ret + } // end of method TupleTests::get_AccessPartiallyNamed + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`1 + get_NewTuple1() cil managed + { + // Code size 7 (0x7) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: newobj instance void valuetype [mscorlib]System.ValueTuple`1::.ctor(!0) + IL_0006: ret + } // end of method TupleTests::get_NewTuple1 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_NewTuple2() cil managed + { + .param [0] + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_0007: ret + } // end of method TupleTests::get_NewTuple2 + + .method public hidebysig specialname instance object + get_BoxedTuple10() cil managed + { + // Code size 28 (0x1c) + .maxstack 10 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: ldc.i4.4 + IL_0004: ldc.i4.5 + IL_0005: ldc.i4.6 + IL_0006: ldc.i4.7 + IL_0007: ldc.i4.8 + IL_0008: ldc.i4.s 9 + IL_000a: ldc.i4.s 10 + IL_000c: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_0011: newobj instance void valuetype [mscorlib]System.ValueTuple`8>::.ctor(!0, + !1, + !2, + !3, + !4, + !5, + !6, + !7) + IL_0016: box valuetype [mscorlib]System.ValueTuple`8> + IL_001b: ret + } // end of method TupleTests::get_BoxedTuple10 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_SwapUnnamed() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed2 + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Unnamed2 + IL_0011: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_0016: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_001b: ret + } // end of method TupleTests::get_SwapUnnamed + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_SwapNamed2() cil managed + { + // Code size 28 (0x1c) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0006: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_000b: ldarg.0 + IL_000c: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0011: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_0016: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_001b: ret + } // end of method TupleTests::get_SwapNamed2 + + .method public hidebysig specialname instance int32 + get_TupleHash() cil managed + { + // Code size 23 (0x17) + .maxstack 3 + .locals init (valuetype [mscorlib]System.ValueTuple`3 V_0) + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_0008: stloc.0 + IL_0009: ldloca.s V_0 + IL_000b: constrained. valuetype [mscorlib]System.ValueTuple`3 + IL_0011: callvirt instance int32 [mscorlib]System.Object::GetHashCode() + IL_0016: ret + } // end of method TupleTests::get_TupleHash + + .method public hidebysig specialname instance int32 + get_TupleHash2() cil managed + { + // Code size 18 (0x12) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: ldflda valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::Named2 + IL_0006: constrained. valuetype [mscorlib]System.ValueTuple`2 + IL_000c: callvirt instance int32 [mscorlib]System.Object::GetHashCode() + IL_0011: ret + } // end of method TupleTests::get_TupleHash2 + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`2 + get_AccessRest() cil managed + { + // Code size 26 (0x1a) + .maxstack 9 + IL_0000: ldc.i4.1 + IL_0001: ldc.i4.2 + IL_0002: ldc.i4.3 + IL_0003: ldc.i4.4 + IL_0004: ldc.i4.5 + IL_0005: ldc.i4.6 + IL_0006: ldc.i4.7 + IL_0007: ldc.i4.8 + IL_0008: ldc.i4.s 9 + IL_000a: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_000f: newobj instance void valuetype [mscorlib]System.ValueTuple`8>::.ctor(!0, + !1, + !2, + !3, + !4, + !5, + !6, + !7) + IL_0014: ldfld !7 valuetype [mscorlib]System.ValueTuple`8>::Rest + IL_0019: ret + } // end of method TupleTests::get_AccessRest + + .method public hidebysig specialname instance valuetype [mscorlib]System.ValueTuple`3 + get_TargetTyping() cil managed + { + // Code size 44 (0x2c) + .maxstack 8 + IL_0000: ldnull + IL_0001: ldc.i4.1 + IL_0002: box [mscorlib]System.Int32 + IL_0007: ldsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__45_0' + IL_000c: dup + IL_000d: brtrue.s IL_0026 + + IL_000f: pop + IL_0010: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'b__45_0'() + IL_001b: newobj instance void [mscorlib]System.Action::.ctor(object, + native int) + IL_0020: dup + IL_0021: stsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__45_0' + IL_0026: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_002b: ret + } // end of method TupleTests::get_TargetTyping + + .method public hidebysig specialname instance object + get_NotTargetTyping() cil managed + { + // Code size 49 (0x31) + .maxstack 8 + IL_0000: ldnull + IL_0001: ldc.i4.1 + IL_0002: box [mscorlib]System.Int32 + IL_0007: ldsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__47_0' + IL_000c: dup + IL_000d: brtrue.s IL_0026 + + IL_000f: pop + IL_0010: ldsfld class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c' ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9' + IL_0015: ldftn instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'b__47_0'() + IL_001b: newobj instance void [mscorlib]System.Action::.ctor(object, + native int) + IL_0020: dup + IL_0021: stsfld class [mscorlib]System.Action ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests/'<>c'::'<>9__47_0' + IL_0026: newobj instance void valuetype [mscorlib]System.ValueTuple`3::.ctor(!0, + !1, + !2) + IL_002b: box valuetype [mscorlib]System.ValueTuple`3 + IL_0030: ret + } // end of method TupleTests::get_NotTargetTyping + + .method public hidebysig instance void + UseDict() cil managed + { + // Code size 109 (0x6d) + .maxstack 3 + .locals init (string V_0, + bool V_1) + IL_0000: nop + IL_0001: ldarg.0 + IL_0002: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0007: callvirt instance int32 class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Count() + IL_000c: ldc.i4.s 10 + IL_000e: cgt + IL_0010: stloc.1 + IL_0011: ldloc.1 + IL_0012: brfalse.s IL_0022 + + IL_0014: nop + IL_0015: ldarg.0 + IL_0016: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_001b: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::Clear() + IL_0020: nop + IL_0021: nop + IL_0022: ldarg.0 + IL_0023: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0028: ldc.i4.1 + IL_0029: ldstr "abc" + IL_002e: newobj instance void valuetype [mscorlib]System.ValueTuple`2::.ctor(!0, + !1) + IL_0033: callvirt instance !1 class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Item(!0) + IL_0038: ldfld !0 valuetype [mscorlib]System.ValueTuple`2::Item1 + IL_003d: stloc.0 + IL_003e: ldloc.0 + IL_003f: call void [mscorlib]System.Console::WriteLine(string) + IL_0044: nop + IL_0045: ldloc.0 + IL_0046: call void [mscorlib]System.Console::WriteLine(string) + IL_004b: nop + IL_004c: ldarg.0 + IL_004d: ldfld class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2> ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::TupleDict + IL_0052: callvirt instance class [mscorlib]System.Collections.Generic.Dictionary`2/ValueCollection class [mscorlib]System.Collections.Generic.Dictionary`2,valuetype [mscorlib]System.ValueTuple`2>::get_Values() + IL_0057: call class [mscorlib]System.Collections.Generic.List`1 [System.Core]System.Linq.Enumerable::ToList>(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_005c: call !!0 [System.Core]System.Linq.Enumerable::First>(class [mscorlib]System.Collections.Generic.IEnumerable`1) + IL_0061: ldfld !1 valuetype [mscorlib]System.ValueTuple`2::Item2 + IL_0066: call void [mscorlib]System.Console::WriteLine(int32) + IL_006b: nop + IL_006c: ret + } // end of method TupleTests::UseDict + + .method public hidebysig specialname rtspecialname + instance void .ctor() cil managed + { + // Code size 8 (0x8) + .maxstack 8 + IL_0000: ldarg.0 + IL_0001: call instance void [mscorlib]System.Object::.ctor() + IL_0006: nop + IL_0007: ret + } // end of method TupleTests::.ctor + + .property instance int32 VT1Member() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_VT1Member() + } // end of property TupleTests::VT1Member + .property instance int32 AccessUnnamed8() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessUnnamed8() + } // end of property TupleTests::AccessUnnamed8 + .property instance int32 AccessNamed8() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessNamed8() + } // end of property TupleTests::AccessNamed8 + .property instance int32 AccessPartiallyNamed() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessPartiallyNamed() + } // end of property TupleTests::AccessPartiallyNamed + .property instance valuetype [mscorlib]System.ValueTuple`1 + NewTuple1() + { + .get instance valuetype [mscorlib]System.ValueTuple`1 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NewTuple1() + } // end of property TupleTests::NewTuple1 + .property instance valuetype [mscorlib]System.ValueTuple`2 + NewTuple2() + { + .custom instance void [mscorlib]System.Runtime.CompilerServices.TupleElementNamesAttribute::.ctor(string[]) = ( 01 00 02 00 00 00 01 61 01 62 00 00 ) // .......a.b.. + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NewTuple2() + } // end of property TupleTests::NewTuple2 + .property instance object BoxedTuple10() + { + .get instance object ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_BoxedTuple10() + } // end of property TupleTests::BoxedTuple10 + .property instance valuetype [mscorlib]System.ValueTuple`2 + SwapUnnamed() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_SwapUnnamed() + } // end of property TupleTests::SwapUnnamed + .property instance valuetype [mscorlib]System.ValueTuple`2 + SwapNamed2() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_SwapNamed2() + } // end of property TupleTests::SwapNamed2 + .property instance int32 TupleHash() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TupleHash() + } // end of property TupleTests::TupleHash + .property instance int32 TupleHash2() + { + .get instance int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TupleHash2() + } // end of property TupleTests::TupleHash2 + .property instance valuetype [mscorlib]System.ValueTuple`2 + AccessRest() + { + .get instance valuetype [mscorlib]System.ValueTuple`2 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_AccessRest() + } // end of property TupleTests::AccessRest + .property instance valuetype [mscorlib]System.ValueTuple`3 + TargetTyping() + { + .get instance valuetype [mscorlib]System.ValueTuple`3 ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_TargetTyping() + } // end of property TupleTests::TargetTyping + .property instance object NotTargetTyping() + { + .get instance object ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests::get_NotTargetTyping() + } // end of property TupleTests::NotTargetTyping +} // end of class ICSharpCode.Decompiler.Tests.TestCases.Pretty.TupleTests + + +// ============================================================= + +// *********** DISASSEMBLY COMPLETE *********************** diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.cs index fe6f8aadb..917513287 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.cs @@ -244,5 +244,10 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty { return string.Equals("", "", b ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase); } + + public bool MethodCallOnEnumConstant() + { + return AttributeTargets.All.HasFlag(AttributeTargets.Assembly); + } } } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.il index 0e3b5cb83..ca1368caa 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly mu5mxl5m +.assembly TypeAnalysisTests { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module mu5mxl5m.dll -// MVID: {DBFE6CB1-ED58-473D-986E-A633C15C8AEE} +.module TypeAnalysisTests.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04E10000 // =============== CLASS MEMBERS DECLARATION =================== @@ -848,6 +844,25 @@ IL_001c: ret } // end of method TypeAnalysisTests::EnumInConditionalOperator + .method public hidebysig instance bool + MethodCallOnEnumConstant() cil managed + { + // Code size 27 (0x1b) + .maxstack 2 + .locals init (bool V_0) + IL_0000: nop + IL_0001: ldc.i4 0x7fff + IL_0006: box [mscorlib]System.AttributeTargets + IL_000b: ldc.i4.1 + IL_000c: box [mscorlib]System.AttributeTargets + IL_0011: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0016: stloc.0 + IL_0017: br.s IL_0019 + + IL_0019: ldloc.0 + IL_001a: ret + } // end of method TypeAnalysisTests::MethodCallOnEnumConstant + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -864,4 +879,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\TypeAnalysisTests.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.il index fb0c04e29..82382a638 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly tbojr2zd +.assembly TypeAnalysisTests.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module tbojr2zd.dll -// MVID: {A417EC21-8726-4629-9E82-47FE9895CD81} +.module TypeAnalysisTests.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x05150000 // =============== CLASS MEMBERS DECLARATION =================== @@ -586,6 +582,19 @@ IL_0016: ret } // end of method TypeAnalysisTests::EnumInConditionalOperator + .method public hidebysig instance bool + MethodCallOnEnumConstant() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldc.i4 0x7fff + IL_0005: box [mscorlib]System.AttributeTargets + IL_000a: ldc.i4.1 + IL_000b: box [mscorlib]System.AttributeTargets + IL_0010: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0015: ret + } // end of method TypeAnalysisTests::MethodCallOnEnumConstant + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { @@ -602,4 +611,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\TypeAnalysisTests.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.roslyn.il index 086fc7382..0a7d1beb4 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.opt.roslyn.il @@ -584,6 +584,19 @@ IL_0016: ret } // end of method TypeAnalysisTests::EnumInConditionalOperator + .method public hidebysig instance bool + MethodCallOnEnumConstant() cil managed + { + // Code size 22 (0x16) + .maxstack 8 + IL_0000: ldc.i4 0x7fff + IL_0005: box [mscorlib]System.AttributeTargets + IL_000a: ldc.i4.1 + IL_000b: box [mscorlib]System.AttributeTargets + IL_0010: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0015: ret + } // end of method TypeAnalysisTests::MethodCallOnEnumConstant + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.roslyn.il index dcbb55b08..58f12ef8d 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/TypeAnalysisTests.roslyn.il @@ -842,6 +842,25 @@ IL_001b: ret } // end of method TypeAnalysisTests::EnumInConditionalOperator + .method public hidebysig instance bool + MethodCallOnEnumConstant() cil managed + { + // Code size 27 (0x1b) + .maxstack 2 + .locals init (bool V_0) + IL_0000: nop + IL_0001: ldc.i4 0x7fff + IL_0006: box [mscorlib]System.AttributeTargets + IL_000b: ldc.i4.1 + IL_000c: box [mscorlib]System.AttributeTargets + IL_0011: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum) + IL_0016: stloc.0 + IL_0017: br.s IL_0019 + + IL_0019: ldloc.0 + IL_001a: ret + } // end of method TypeAnalysisTests::MethodCallOnEnumConstant + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.il index db976e7e8..17a4c65d4 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly wbbysi3m +.assembly UnsafeCode { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module wbbysi3m.dll -// MVID: {8A733FFA-BF2C-4A07-BAE8-CC2DB20691C0} +.module UnsafeCode.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04D30000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1445,4 +1441,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\UnsafeCode.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.il index 69d0fe70d..2e66e0b43 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly apfrp3oh +.assembly UnsafeCode.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module apfrp3oh.dll -// MVID: {18CFEE2F-79CA-4464-BA60-BA8E54BE2D99} +.module UnsafeCode.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04CA0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -1165,4 +1161,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\work\ILSpy\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\UnsafeCode.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.roslyn.il index db01999fd..e333e1afe 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.opt.roslyn.il @@ -841,31 +841,29 @@ FixedMemberAccess(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers* m, int32 i) cil managed { - // Code size 39 (0x27) + // Code size 37 (0x25) .maxstack 8 IL_0000: ldarg.1 IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers IL_0006: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_000b: conv.u - IL_000c: ldarg.2 - IL_000d: conv.i - IL_000e: ldc.i4.4 - IL_000f: mul - IL_0010: add - IL_0011: ldind.i4 - IL_0012: conv.r8 - IL_0013: ldarg.1 - IL_0014: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Doubles - IL_0019: ldflda float64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_001e: conv.u - IL_001f: ldarg.2 - IL_0020: conv.i - IL_0021: ldc.i4.8 - IL_0022: mul + IL_000b: ldarg.2 + IL_000c: conv.i + IL_000d: ldc.i4.4 + IL_000e: mul + IL_000f: add + IL_0010: ldind.i4 + IL_0011: conv.r8 + IL_0012: ldarg.1 + IL_0013: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Doubles + IL_0018: ldflda float64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField + IL_001d: ldarg.2 + IL_001e: conv.i + IL_001f: ldc.i4.8 + IL_0020: mul + IL_0021: add + IL_0022: ldind.r8 IL_0023: add - IL_0024: ldind.r8 - IL_0025: add - IL_0026: ret + IL_0024: ret } // end of method UnsafeCode::FixedMemberAccess .method public hidebysig instance float64* @@ -898,7 +896,7 @@ .method public hidebysig instance void UseFixedMemberAsReference(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers* m) cil managed { - // Code size 39 (0x27) + // Code size 38 (0x26) .maxstack 8 IL_0000: ldarg.0 IL_0001: ldarg.1 @@ -910,11 +908,10 @@ IL_0013: ldarg.1 IL_0014: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers IL_0019: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_001e: conv.u - IL_001f: ldc.i4.4 - IL_0020: add - IL_0021: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode::UseReference(int32&) - IL_0026: ret + IL_001e: ldc.i4.4 + IL_001f: add + IL_0020: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode::UseReference(int32&) + IL_0025: ret } // end of method UnsafeCode::UseFixedMemberAsReference .method public hidebysig instance void @@ -923,7 +920,7 @@ // Code size 27 (0x1b) .maxstack 2 .locals init (int32* V_0, - int32*& pinned V_1) + int32& pinned V_1) IL_0000: ldarg.1 IL_0001: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers IL_0006: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.roslyn.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.roslyn.il index 2e6e21218..c0d06577a 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.roslyn.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/UnsafeCode.roslyn.il @@ -1053,37 +1053,35 @@ FixedMemberAccess(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers* m, int32 i) cil managed { - // Code size 44 (0x2c) + // Code size 42 (0x2a) .maxstack 4 .locals init (float64 V_0) IL_0000: nop IL_0001: ldarg.1 IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers IL_0007: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_000c: conv.u - IL_000d: ldarg.2 - IL_000e: conv.i - IL_000f: ldc.i4.4 - IL_0010: mul - IL_0011: add - IL_0012: ldind.i4 - IL_0013: conv.r8 - IL_0014: ldarg.1 - IL_0015: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Doubles - IL_001a: ldflda float64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_001f: conv.u - IL_0020: ldarg.2 - IL_0021: conv.i - IL_0022: ldc.i4.8 - IL_0023: mul + IL_000c: ldarg.2 + IL_000d: conv.i + IL_000e: ldc.i4.4 + IL_000f: mul + IL_0010: add + IL_0011: ldind.i4 + IL_0012: conv.r8 + IL_0013: ldarg.1 + IL_0014: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Doubles + IL_0019: ldflda float64 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField + IL_001e: ldarg.2 + IL_001f: conv.i + IL_0020: ldc.i4.8 + IL_0021: mul + IL_0022: add + IL_0023: ldind.r8 IL_0024: add - IL_0025: ldind.r8 - IL_0026: add - IL_0027: stloc.0 - IL_0028: br.s IL_002a + IL_0025: stloc.0 + IL_0026: br.s IL_0028 - IL_002a: ldloc.0 - IL_002b: ret + IL_0028: ldloc.0 + IL_0029: ret } // end of method UnsafeCode::FixedMemberAccess .method public hidebysig instance float64* @@ -1123,7 +1121,7 @@ .method public hidebysig instance void UseFixedMemberAsReference(valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers* m) cil managed { - // Code size 42 (0x2a) + // Code size 41 (0x29) .maxstack 8 IL_0000: nop IL_0001: ldarg.0 @@ -1137,12 +1135,11 @@ IL_0015: ldarg.1 IL_0016: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers IL_001b: ldflda int32 ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer'::FixedElementField - IL_0020: conv.u - IL_0021: ldc.i4.4 - IL_0022: add - IL_0023: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode::UseReference(int32&) - IL_0028: nop - IL_0029: ret + IL_0020: ldc.i4.4 + IL_0021: add + IL_0022: call instance void ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode::UseReference(int32&) + IL_0027: nop + IL_0028: ret } // end of method UnsafeCode::UseFixedMemberAsReference .method public hidebysig instance void @@ -1151,7 +1148,7 @@ // Code size 30 (0x1e) .maxstack 2 .locals init (int32* V_0, - int32*& pinned V_1) + int32& pinned V_1) IL_0000: nop IL_0001: ldarg.1 IL_0002: ldflda valuetype ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers/'e__FixedBuffer' ICSharpCode.Decompiler.Tests.TestCases.Pretty.UnsafeCode/StructWithFixedSizeMembers::Integers diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.il index 9f08d8d24..f810b46a5 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly wgewqkaz +.assembly Using { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module wgewqkaz.dll -// MVID: {298A3373-9EF1-4D76-BCEC-2E82A945AF55} +.module Using.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x00550000 // =============== CLASS MEMBERS DECLARATION =================== @@ -519,4 +515,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Using.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.opt.il index 79a3b695b..a6d756f0b 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/Using.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.0.30319.17929 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly ms0npdxf +.assembly Using.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module ms0npdxf.dll -// MVID: {060FC94F-8DAE-4720-AF67-48BEEC70FFC8} +.module Using.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x030B0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -408,4 +404,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\Using.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.il index cad9efae2..f5c512f6e 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly sw5i42xa +.assembly VariableNaming { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module sw5i42xa.dll -// MVID: {863C0756-F3DB-4C0E-BC40-5DDA3E7F1B18} +.module VariableNaming.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x02C40000 // =============== CLASS MEMBERS DECLARATION =================== @@ -97,4 +93,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\VariableNaming.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.opt.il index b7416f2b6..fc3a8ca8a 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNaming.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly kt4vyfax +.assembly VariableNaming.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module kt4vyfax.dll -// MVID: {2FDC68D5-1FEC-45A6-BADC-43373DBD141E} +.module VariableNaming.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x05090000 // =============== CLASS MEMBERS DECLARATION =================== @@ -93,4 +89,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\VariableNaming.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.il index 11981dd60..2d01a84ee 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly guxeth2f +.assembly VariableNamingWithoutSymbols { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module guxeth2f.dll -// MVID: {D7E12634-3178-4FDA-B3F4-CE4846CACB94} +.module VariableNamingWithoutSymbols.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x04ED0000 // =============== CLASS MEMBERS DECLARATION =================== @@ -97,4 +93,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\VariableNamingWithoutSymbols.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.opt.il index 914f88157..223e56ab8 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/VariableNamingWithoutSymbols.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly wl1juwwv +.assembly VariableNamingWithoutSymbols.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module wl1juwwv.dll -// MVID: {F60C4045-F949-4857-AE4D-AD0ED806A44F} +.module VariableNamingWithoutSymbols.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03250000 // =============== CLASS MEMBERS DECLARATION =================== @@ -93,4 +89,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file ../../../TestCases/Pretty\VariableNamingWithoutSymbols.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.il index c5df8965b..fb0d45121 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '44dbunlx' +.assembly WellKnownConstants { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '44dbunlx.dll' -// MVID: {084D6FE7-6C94-46BC-9CF1-21040E4EE5EA} +.module WellKnownConstants.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03200000 // =============== CLASS MEMBERS DECLARATION =================== @@ -128,4 +124,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\WellKnownConstants.res diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.opt.il b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.opt.il index b22b292eb..eda9ed8c1 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.opt.il +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/WellKnownConstants.opt.il @@ -1,6 +1,4 @@ -// Microsoft (R) .NET Framework IL Disassembler. Version 4.6.1055.0 -// Copyright (c) Microsoft Corporation. All rights reserved. @@ -10,7 +8,7 @@ .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4.. .ver 4:0:0:0 } -.assembly '2a1zmun4' +.assembly WellKnownConstants.opt { .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. @@ -20,15 +18,13 @@ .hash algorithm 0x00008004 .ver 0:0:0:0 } -.module '2a1zmun4.dll' -// MVID: {68191A55-6426-48F1-B0FE-6B515D64B18A} +.module WellKnownConstants.opt.dll .custom instance void [mscorlib]System.Security.UnverifiableCodeAttribute::.ctor() = ( 01 00 00 00 ) .imagebase 0x10000000 .file alignment 0x00000200 .stackreserve 0x00100000 .subsystem 0x0003 // WINDOWS_CUI .corflags 0x00000001 // ILONLY -// Image base: 0x03170000 // =============== CLASS MEMBERS DECLARATION =================== @@ -128,4 +124,3 @@ // ============================================================= // *********** DISASSEMBLY COMPLETE *********************** -// WARNING: Created Win32 resource file C:\Users\Siegfried\Projects\ILSpy master\ICSharpCode.Decompiler.Tests\bin\Debug\net46\../../../TestCases/Pretty\WellKnownConstants.opt.res diff --git a/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemHelper.cs b/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemHelper.cs new file mode 100644 index 000000000..d8517938e --- /dev/null +++ b/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemHelper.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.Tests.TypeSystem +{ + public static class TypeSystemHelper + { + public static ICompilation CreateCompilation(params IUnresolvedTypeDefinition[] unresolvedTypeDefinitions) + { + var unresolvedAsm = new DefaultUnresolvedAssembly("dummy"); + foreach (var typeDef in unresolvedTypeDefinitions) + unresolvedAsm.AddTypeDefinition(typeDef); + return new SimpleCompilation(unresolvedAsm, TypeSystemLoaderTests.Mscorlib, TypeSystemLoaderTests.SystemCore); + } + } +} diff --git a/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs b/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs index 31e1e7b97..de0f7554f 100644 --- a/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs +++ b/ICSharpCode.Decompiler.Tests/TypeSystem/TypeSystemLoaderTests.cs @@ -42,16 +42,21 @@ namespace ICSharpCode.Decompiler.Tests.TypeSystem return new CecilLoader().LoadAssemblyFile(typeof(System.Linq.Enumerable).Assembly.Location); }); + static readonly Lazy testAssembly = new Lazy( + delegate { + return new CecilLoader { IncludeInternalMembers = true }.LoadAssemblyFile(typeof(SimplePublicClass).Assembly.Location); + }); + public static IUnresolvedAssembly Mscorlib { get { return mscorlib.Value; } } public static IUnresolvedAssembly SystemCore { get { return systemCore.Value; } } + public static IUnresolvedAssembly TestAssembly { get { return testAssembly.Value; } } [OneTimeSetUp] public void FixtureSetUp() { // use "IncludeInternalMembers" so that Cecil results match C# parser results CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true }; - IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(SimplePublicClass).Assembly.Location); - compilation = new SimpleCompilation(asm, Mscorlib); + compilation = new SimpleCompilation(TestAssembly, Mscorlib); } protected ICompilation compilation; diff --git a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs index 452089f2e..3667696c2 100644 --- a/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs +++ b/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs @@ -187,7 +187,7 @@ namespace ICSharpCode.Decompiler.CSharp } public CSharpDecompiler(ModuleDefinition module, DecompilerSettings settings) - : this(new DecompilerTypeSystem(module), settings) + : this(new DecompilerTypeSystem(module, settings), settings) { } @@ -229,6 +229,8 @@ namespace ICSharpCode.Decompiler.CSharp if (settings.AnonymousTypes && type.IsAnonymousType()) return true; } + if (settings.ArrayInitializers && settings.SwitchStatementOnString && type.Name.StartsWith("", StringComparison.Ordinal)) + return true; } FieldDefinition field = member as FieldDefinition; @@ -244,12 +246,15 @@ namespace ICSharpCode.Decompiler.CSharp // event-fields are not [CompilerGenerated] if (settings.AutomaticEvents && field.DeclaringType.Events.Any(ev => ev.Name == field.Name)) return true; - // HACK : only hide fields starting with '__StaticArrayInit' if (settings.ArrayInitializers && field.DeclaringType.Name.StartsWith("", StringComparison.Ordinal)) { + // hide fields starting with '__StaticArrayInit' if (field.Name.StartsWith("__StaticArrayInit", StringComparison.Ordinal)) return true; if (field.FieldType.Name.StartsWith("__StaticArrayInit", StringComparison.Ordinal)) return true; + // hide fields starting with '$$method' + if (field.Name.StartsWith("$$method", StringComparison.Ordinal)) + return true; } } @@ -1369,6 +1374,16 @@ namespace ICSharpCode.Decompiler.CSharp HasNullableSpecifier = true }; } + if (CecilLoader.IsValueTuple(gType, out int tupleCardinality) && tupleCardinality > 1 && tupleCardinality < TupleType.RestPosition) { + var tupleType = new TupleAstType(); + foreach (var typeArgument in gType.GenericArguments) { + typeIndex++; + tupleType.Elements.Add(new TupleTypeElement { + Type = ConvertType(typeArgument, typeAttributes, ref typeIndex, options) + }); + } + return tupleType; + } AstType baseType = ConvertType(gType.ElementType, typeAttributes, ref typeIndex, options & ~ConvertTypeOptions.IncludeTypeParameterDefinitions); List typeArguments = new List(); foreach (var typeArgument in gType.GenericArguments) { diff --git a/ICSharpCode.Decompiler/CSharp/CSharpLanguageVersion.cs b/ICSharpCode.Decompiler/CSharp/CSharpLanguageVersion.cs index f6ba85efb..dfde07853 100644 --- a/ICSharpCode.Decompiler/CSharp/CSharpLanguageVersion.cs +++ b/ICSharpCode.Decompiler/CSharp/CSharpLanguageVersion.cs @@ -15,6 +15,7 @@ namespace ICSharpCode.Decompiler.CSharp CSharp7 = 7, CSharp7_1 = 701, CSharp7_2 = 702, + CSharp7_3 = 703, Latest = 0x7FFFFFFF } } diff --git a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs index 544397724..e660452cf 100644 --- a/ICSharpCode.Decompiler/CSharp/CallBuilder.cs +++ b/ICSharpCode.Decompiler/CSharp/CallBuilder.cs @@ -18,6 +18,7 @@ using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using ICSharpCode.Decompiler.CSharp.Resolver; @@ -56,6 +57,23 @@ namespace ICSharpCode.Decompiler.CSharp if (inst is NewObj newobj && IL.Transforms.DelegateConstruction.IsDelegateConstruction(newobj, true)) { return HandleDelegateConstruction(newobj); } + if (settings.TupleTypes && TupleTransform.MatchTupleConstruction(inst as NewObj, out var tupleElements) && tupleElements.Length >= 2) { + var elementTypes = TupleType.GetTupleElementTypes(inst.Method.DeclaringType); + Debug.Assert(!elementTypes.IsDefault, "MatchTupleConstruction should not success unless we got a valid tuple type."); + Debug.Assert(elementTypes.Length == tupleElements.Length); + var tuple = new TupleExpression(); + var elementRRs = new List(); + foreach (var (element, elementType) in tupleElements.Zip(elementTypes)) { + var translatedElement = expressionBuilder.Translate(element, elementType) + .ConvertTo(elementType, expressionBuilder, allowImplicitConversion: true); + tuple.Elements.Add(translatedElement.Expression); + elementRRs.Add(translatedElement.ResolveResult); + } + return tuple.WithRR(new TupleResolveResult( + expressionBuilder.compilation, + elementRRs.ToImmutableArray() + )).WithILInstruction(inst); + } return Build(inst.OpCode, inst.Method, inst.Arguments, inst.ConstrainedTo).WithILInstruction(inst); } @@ -70,9 +88,12 @@ namespace ICSharpCode.Decompiler.CSharp if (callOpCode == OpCode.NewObj) { target = default(TranslatedExpression); // no target } else { - target = expressionBuilder.TranslateTarget(method, callArguments.FirstOrDefault(), callOpCode == OpCode.Call, constrainedTo); - if (callOpCode == OpCode.CallVirt - && constrainedTo == null + target = expressionBuilder.TranslateTarget( + callArguments.FirstOrDefault(), + nonVirtualInvocation: callOpCode == OpCode.Call, + memberStatic: method.IsStatic, + memberDeclaringType: constrainedTo ?? method.DeclaringType); + if (constrainedTo == null && target.Expression is CastExpression cast && target.ResolveResult is ConversionResolveResult conversion && target.Type.IsKnownType(KnownTypeCode.Object) @@ -117,7 +138,7 @@ namespace ICSharpCode.Decompiler.CSharp expandedArguments.Add(expressionBuilder.GetDefaultValueExpression(elementType).WithoutILInstruction()); } } - if (IsUnambiguousCall(expectedTargetDetails, method, target.ResolveResult, Empty.Array, expandedArguments) == OverloadResolutionErrors.None) { + if (IsUnambiguousCall(expectedTargetDetails, method, target.ResolveResult, Empty.Array, expandedArguments, out _) == OverloadResolutionErrors.None) { isExpandedForm = true; expectedParameters = expandedParameters; arguments = expandedArguments.SelectList(a => new TranslatedExpression(a.Expression.Detach())); @@ -156,9 +177,8 @@ namespace ICSharpCode.Decompiler.CSharp var argumentResolveResults = arguments.Select(arg => arg.ResolveResult).ToList(); - ResolveResult rr = new CSharpInvocationResolveResult(target.ResolveResult, method, argumentResolveResults, isExpandedForm: isExpandedForm); - if (callOpCode == OpCode.NewObj) { + ResolveResult rr = new CSharpInvocationResolveResult(target.ResolveResult, method, argumentResolveResults, isExpandedForm: isExpandedForm); if (settings.AnonymousTypes && method.DeclaringType.IsAnonymousType()) { var argumentExpressions = arguments.SelectArray(arg => arg.Expression); AnonymousTypeCreateExpression atce = new AnonymousTypeCreateExpression(); @@ -176,7 +196,7 @@ namespace ICSharpCode.Decompiler.CSharp return atce .WithRR(rr); } else { - if (IsUnambiguousCall(expectedTargetDetails, method, null, Empty.Array, arguments) != OverloadResolutionErrors.None) { + if (IsUnambiguousCall(expectedTargetDetails, method, null, Empty.Array, arguments, out _) != OverloadResolutionErrors.None) { for (int i = 0; i < arguments.Count; i++) { if (settings.AnonymousTypes && expectedParameters[i].Type.ContainsAnonymousType()) { if (arguments[i].Expression is LambdaExpression lambda) { @@ -195,10 +215,11 @@ namespace ICSharpCode.Decompiler.CSharp if (method.IsAccessor && (method.AccessorOwner.SymbolKind == SymbolKind.Indexer || expectedParameters.Count == allowedParamCount)) { return HandleAccessorCall(expectedTargetDetails, method, target, arguments.ToList()); } else if (method.Name == "Invoke" && method.DeclaringType.Kind == TypeKind.Delegate && !IsNullConditional(target)) { - return new InvocationExpression(target, arguments.Select(arg => arg.Expression)).WithRR(rr); + return new InvocationExpression(target, arguments.Select(arg => arg.Expression)) + .WithRR(new CSharpInvocationResolveResult(target.ResolveResult, method, argumentResolveResults, isExpandedForm: isExpandedForm)); } else if (IsDelegateEqualityComparison(method, arguments)) { return HandleDelegateEqualityComparison(method, arguments) - .WithRR(rr); + .WithRR(new CSharpInvocationResolveResult(target.ResolveResult, method, argumentResolveResults, isExpandedForm: isExpandedForm)); } else if (method.IsOperator && method.Name == "op_Implicit" && arguments.Count == 1) { return HandleImplicitConversion(method, arguments[0]); } else { @@ -209,15 +230,20 @@ namespace ICSharpCode.Decompiler.CSharp } else { if (method.IsStatic) requireTarget = !expressionBuilder.IsCurrentOrContainingType(method.DeclaringTypeDefinition) || method.Name == ".cctor"; + else if (method.Name == ".ctor") + requireTarget = true; // always use target for base/this-ctor-call, the constructor initializer pattern depends on this + else if (target.Expression is BaseReferenceExpression) + requireTarget = (callOpCode != OpCode.CallVirt && method.IsVirtual); else - requireTarget = !(target.Expression is ThisReferenceExpression || target.Expression is BaseReferenceExpression) || method.Name == ".ctor"; + requireTarget = !(target.Expression is ThisReferenceExpression); } bool targetCasted = false; bool argumentsCasted = false; IType[] typeArguments = Empty.Array; var targetResolveResult = requireTarget ? target.ResolveResult : null; + IParameterizedMember foundMethod; OverloadResolutionErrors errors; - while ((errors = IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, typeArguments, arguments)) != OverloadResolutionErrors.None) { + while ((errors = IsUnambiguousCall(expectedTargetDetails, method, targetResolveResult, typeArguments, arguments, out foundMethod)) != OverloadResolutionErrors.None) { switch (errors) { case OverloadResolutionErrors.TypeInferenceFailed: case OverloadResolutionErrors.WrongNumberOfTypeArguments: @@ -254,8 +280,12 @@ namespace ICSharpCode.Decompiler.CSharp } continue; } + // We've given up. + foundMethod = method; break; } + // Note: after this loop, 'method' and 'foundMethod' may differ, + // but as far as allowed by IsAppropriateCallTarget(). Expression targetExpr; string methodName = method.Name; @@ -279,7 +309,8 @@ namespace ICSharpCode.Decompiler.CSharp if (requireTypeArguments && (!settings.AnonymousTypes || !method.TypeArguments.Any(a => a.ContainsAnonymousType()))) typeArgumentList.AddRange(method.TypeArguments.Select(expressionBuilder.ConvertType)); var argumentExpressions = arguments.Select(arg => arg.Expression); - return new InvocationExpression(targetExpr, argumentExpressions).WithRR(rr); + return new InvocationExpression(targetExpr, argumentExpressions) + .WithRR(new CSharpInvocationResolveResult(target.ResolveResult, foundMethod, argumentResolveResults, isExpandedForm: isExpandedForm)); } } } @@ -349,8 +380,10 @@ namespace ICSharpCode.Decompiler.CSharp } OverloadResolutionErrors IsUnambiguousCall(ExpectedTargetDetails expectedTargetDetails, IMethod method, - ResolveResult target, IType[] typeArguments, IList arguments) + ResolveResult target, IType[] typeArguments, IList arguments, + out IParameterizedMember foundMember) { + foundMember = null; var lookup = new MemberLookup(resolver.CurrentTypeDefinition, resolver.CurrentTypeDefinition.ParentAssembly); var or = new OverloadResolution(resolver.Compilation, arguments.SelectArray(a => a.ResolveResult), typeArguments: typeArguments); if (expectedTargetDetails.CallOpCode == OpCode.NewObj) { @@ -372,7 +405,10 @@ namespace ICSharpCode.Decompiler.CSharp } if (or.BestCandidateErrors != OverloadResolutionErrors.None) return or.BestCandidateErrors; - if (!IsAppropriateCallTarget(expectedTargetDetails, method, or.GetBestCandidateWithSubstitutedTypeArguments())) + if (or.IsAmbiguous) + return OverloadResolutionErrors.AmbiguousMatch; + foundMember = or.GetBestCandidateWithSubstitutedTypeArguments(); + if (!IsAppropriateCallTarget(expectedTargetDetails, method, foundMember)) return OverloadResolutionErrors.AmbiguousMatch; return OverloadResolutionErrors.None; } @@ -395,16 +431,31 @@ namespace ICSharpCode.Decompiler.CSharp return true; } - bool IsUnambiguousAccess(ExpectedTargetDetails expectedTargetDetails, ResolveResult target, IMethod method) + bool IsUnambiguousAccess(ExpectedTargetDetails expectedTargetDetails, ResolveResult target, IMethod method, out IMember foundMember) { + foundMember = null; + MemberResolveResult result; if (target == null) { - var result = resolver.ResolveSimpleName(method.AccessorOwner.Name, EmptyList.Instance, isInvocationTarget: false) as MemberResolveResult; - return !(result == null || result.IsError || !IsAppropriateCallTarget(expectedTargetDetails, method.AccessorOwner, result.Member)); + result = resolver.ResolveSimpleName(method.AccessorOwner.Name, EmptyList.Instance, isInvocationTarget: false) as MemberResolveResult; } else { var lookup = new MemberLookup(resolver.CurrentTypeDefinition, resolver.CurrentTypeDefinition.ParentAssembly); - var result = lookup.Lookup(target, method.AccessorOwner.Name, EmptyList.Instance, isInvocation: false) as MemberResolveResult; - return !(result == null || result.IsError || !IsAppropriateCallTarget(expectedTargetDetails, method.AccessorOwner, result.Member)); + if (method.AccessorOwner.SymbolKind == SymbolKind.Indexer) { + // TODO: use OR here, etc. + result = null; + foreach (var methodList in lookup.LookupIndexers(target)) { + foreach (var indexer in methodList) { + if (IsAppropriateCallTarget(expectedTargetDetails, method.AccessorOwner, indexer)) { + foundMember = indexer; + return true; + } + } + } + } else { + result = lookup.Lookup(target, method.AccessorOwner.Name, EmptyList.Instance, isInvocation: false) as MemberResolveResult; + } } + foundMember = result?.Member; + return !(result == null || result.IsError || !IsAppropriateCallTarget(expectedTargetDetails, method.AccessorOwner, result.Member)); } ExpressionWithResolveResult HandleAccessorCall(ExpectedTargetDetails expectedTargetDetails, IMethod method, TranslatedExpression target, IList arguments) @@ -414,7 +465,8 @@ namespace ICSharpCode.Decompiler.CSharp bool targetCasted = false; var targetResolveResult = requireTarget ? target.ResolveResult : null; - while (!IsUnambiguousAccess(expectedTargetDetails, targetResolveResult, method)) { + IMember foundMember; + while (!IsUnambiguousAccess(expectedTargetDetails, targetResolveResult, method, out foundMember)) { if (!requireTarget) { requireTarget = true; targetResolveResult = target.ResolveResult; @@ -423,11 +475,12 @@ namespace ICSharpCode.Decompiler.CSharp target = target.ConvertTo(method.AccessorOwner.DeclaringType, expressionBuilder); targetResolveResult = target.ResolveResult; } else { + foundMember = method.AccessorOwner; break; } } - var rr = new MemberResolveResult(target.ResolveResult, method.AccessorOwner); + var rr = new MemberResolveResult(target.ResolveResult, foundMember); if (method.ReturnType.IsKnownType(KnownTypeCode.Void)) { var value = arguments.Last(); @@ -472,14 +525,14 @@ namespace ICSharpCode.Decompiler.CSharp bool IsAppropriateCallTarget(ExpectedTargetDetails expectedTargetDetails, IMember expectedTarget, IMember actualTarget) { - if (expectedTarget.Equals(actualTarget)) + if (expectedTarget.Equals(actualTarget, NormalizeTypeVisitor.TypeErasure)) return true; if (expectedTargetDetails.CallOpCode == OpCode.CallVirt && actualTarget.IsOverride) { if (expectedTargetDetails.NeedsBoxingConversion && actualTarget.DeclaringType.IsReferenceType != true) return false; foreach (var possibleTarget in InheritanceHelper.GetBaseMembers(actualTarget, false)) { - if (expectedTarget.Equals(possibleTarget)) + if (expectedTarget.Equals(possibleTarget, NormalizeTypeVisitor.TypeErasure)) return true; if (!possibleTarget.IsOverride) break; @@ -513,7 +566,10 @@ namespace ICSharpCode.Decompiler.CSharp requireTarget = true; } else { targetType = method.DeclaringType; - target = expressionBuilder.TranslateTarget(method, inst.Arguments[0], func.OpCode == OpCode.LdFtn); + target = expressionBuilder.TranslateTarget(inst.Arguments[0], + nonVirtualInvocation: func.OpCode == OpCode.LdFtn, + memberStatic: method.IsStatic, + memberDeclaringType: method.DeclaringType); target = ExpressionBuilder.UnwrapBoxingConversion(target); requireTarget = expressionBuilder.HidesVariableWithName(method.Name) || (method.IsStatic ? !expressionBuilder.IsCurrentOrContainingType(method.DeclaringTypeDefinition) : !(target.Expression is ThisReferenceExpression)); diff --git a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs index 5b8cc7fdc..93c66b85d 100644 --- a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs +++ b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs @@ -194,7 +194,10 @@ namespace ICSharpCode.Decompiler.CSharp ExpressionWithResolveResult ConvertField(IField field, ILInstruction targetInstruction = null) { - var target = TranslateTarget(field, targetInstruction, true); + var target = TranslateTarget(targetInstruction, + nonVirtualInvocation: true, + memberStatic: field.IsStatic, + memberDeclaringType: field.DeclaringType); bool requireTarget = HidesVariableWithName(field.Name) || (field.IsStatic ? !IsCurrentOrContainingType(field.DeclaringTypeDefinition) : !(target.Expression is ThisReferenceExpression || target.Expression is BaseReferenceExpression)); bool targetCasted = false; @@ -204,11 +207,11 @@ namespace ICSharpCode.Decompiler.CSharp { if (targetResolveResult == null) { var result = resolver.ResolveSimpleName(field.Name, EmptyList.Instance, isInvocationTarget: false) as MemberResolveResult; - return !(result == null || result.IsError || !result.Member.Equals(field)); + return !(result == null || result.IsError || !result.Member.Equals(field, NormalizeTypeVisitor.TypeErasure)); } else { var lookup = new MemberLookup(resolver.CurrentTypeDefinition, resolver.CurrentTypeDefinition.ParentAssembly); var result = lookup.Lookup(target.ResolveResult, field.Name, EmptyList.Instance, false) as MemberResolveResult; - return !(result == null || result.IsError || !result.Member.Equals(field)); + return !(result == null || result.IsError || !result.Member.Equals(field, NormalizeTypeVisitor.TypeErasure)); } } @@ -1102,8 +1105,69 @@ namespace ICSharpCode.Decompiler.CSharp .WithILInstruction(inst) .WithRR(resolver.ResolveBinaryOperator(op, left.ResolveResult, right.ResolveResult)); } - - protected internal override TranslatedExpression VisitCompoundAssignmentInstruction(CompoundAssignmentInstruction inst, TranslationContext context) + + protected internal override TranslatedExpression VisitUserDefinedCompoundAssign(UserDefinedCompoundAssign inst, TranslationContext context) + { + var target = Translate(inst.Target); + if (inst.Method.Parameters.Count == 2) { + var value = Translate(inst.Value).ConvertTo(inst.Method.Parameters[1].Type, this); + AssignmentOperatorType? op = GetAssignmentOperatorTypeFromMetadataName(inst.Method.Name); + Debug.Assert(op != null); + + return new AssignmentExpression(target, op.Value, value) + .WithILInstruction(inst) + .WithRR(new OperatorResolveResult(inst.Method.ReturnType, AssignmentExpression.GetLinqNodeType(op.Value, false), inst.Method, inst.IsLifted, new[] { target.ResolveResult, value.ResolveResult })); + } else { + UnaryOperatorType? op = GetUnaryOperatorTypeFromMetadataName(inst.Method.Name, inst.CompoundAssignmentType == CompoundAssignmentType.EvaluatesToOldValue); + Debug.Assert(op != null); + + return new UnaryOperatorExpression(op.Value, target) + .WithILInstruction(inst) + .WithRR(new OperatorResolveResult(inst.Method.ReturnType, UnaryOperatorExpression.GetLinqNodeType(op.Value, false), inst.Method, inst.IsLifted, new[] { target.ResolveResult })); + } + } + + internal static AssignmentOperatorType? GetAssignmentOperatorTypeFromMetadataName(string name) + { + switch (name) { + case "op_Addition": + return AssignmentOperatorType.Add; + case "op_Subtraction": + return AssignmentOperatorType.Subtract; + case "op_Multiply": + return AssignmentOperatorType.Multiply; + case "op_Division": + return AssignmentOperatorType.Divide; + case "op_Modulus": + return AssignmentOperatorType.Modulus; + case "op_BitwiseAnd": + return AssignmentOperatorType.BitwiseAnd; + case "op_BitwiseOr": + return AssignmentOperatorType.BitwiseOr; + case "op_ExclusiveOr": + return AssignmentOperatorType.ExclusiveOr; + case "op_LeftShift": + return AssignmentOperatorType.ShiftLeft; + case "op_RightShift": + return AssignmentOperatorType.ShiftRight; + default: + return null; + } + } + + internal static UnaryOperatorType? GetUnaryOperatorTypeFromMetadataName(string name, bool isPostfix) + { + switch (name) { + case "op_Increment": + return isPostfix ? UnaryOperatorType.PostIncrement : UnaryOperatorType.Increment; + case "op_Decrement": + return isPostfix ? UnaryOperatorType.PostDecrement : UnaryOperatorType.Decrement; + default: + return null; + } + } + + protected internal override TranslatedExpression VisitNumericCompoundAssign(NumericCompoundAssign inst, TranslationContext context) { switch (inst.Operator) { case BinaryNumericOperator.Add: @@ -1131,7 +1195,7 @@ namespace ICSharpCode.Decompiler.CSharp } } - TranslatedExpression HandleCompoundAssignment(CompoundAssignmentInstruction inst, AssignmentOperatorType op) + TranslatedExpression HandleCompoundAssignment(NumericCompoundAssign inst, AssignmentOperatorType op) { var target = Translate(inst.Target); var value = Translate(inst.Value); @@ -1196,7 +1260,7 @@ namespace ICSharpCode.Decompiler.CSharp return resultExpr; } - TranslatedExpression HandleCompoundShift(CompoundAssignmentInstruction inst, AssignmentOperatorType op) + TranslatedExpression HandleCompoundShift(NumericCompoundAssign inst, AssignmentOperatorType op) { Debug.Assert(inst.CompoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue); var target = Translate(inst.Target); @@ -1549,20 +1613,21 @@ namespace ICSharpCode.Decompiler.CSharp } } - internal TranslatedExpression TranslateTarget(IMember member, ILInstruction target, bool nonVirtualInvocation, IType constrainedTo = null) + internal TranslatedExpression TranslateTarget(ILInstruction target, bool nonVirtualInvocation, + bool memberStatic, IType memberDeclaringType) { // If references are missing member.IsStatic might not be set correctly. // Additionally check target for null, in order to avoid a crash. - if (!member.IsStatic && target != null) { - if (nonVirtualInvocation && target.MatchLdThis() && member.DeclaringTypeDefinition != resolver.CurrentTypeDefinition) { + if (!memberStatic && target != null) { + if (nonVirtualInvocation && target.MatchLdThis() && memberDeclaringType.GetDefinition() != resolver.CurrentTypeDefinition) { return new BaseReferenceExpression() .WithILInstruction(target) - .WithRR(new ThisResolveResult(member.DeclaringType, nonVirtualInvocation)); + .WithRR(new ThisResolveResult(memberDeclaringType, nonVirtualInvocation)); } else { - var translatedTarget = Translate(target, constrainedTo ?? member.DeclaringType); - if (CallInstruction.ExpectedTypeForThisPointer(constrainedTo ?? member.DeclaringType) == StackType.Ref && translatedTarget.Type.GetStackType().IsIntegerType()) { + var translatedTarget = Translate(target, memberDeclaringType); + if (CallInstruction.ExpectedTypeForThisPointer(memberDeclaringType) == StackType.Ref && translatedTarget.Type.GetStackType().IsIntegerType()) { // when accessing members on value types, ensure we use a reference and not a pointer - translatedTarget = translatedTarget.ConvertTo(new ByReferenceType(constrainedTo ?? member.DeclaringType), this); + translatedTarget = translatedTarget.ConvertTo(new ByReferenceType(memberDeclaringType), this); } if (translatedTarget.Expression is DirectionExpression) { // (ref x).member => x.member @@ -1581,9 +1646,9 @@ namespace ICSharpCode.Decompiler.CSharp return translatedTarget; } } else { - return new TypeReferenceExpression(ConvertType(member.DeclaringType)) + return new TypeReferenceExpression(ConvertType(memberDeclaringType)) .WithoutILInstruction() - .WithRR(new TypeResolveResult(member.DeclaringType)); + .WithRR(new TypeResolveResult(memberDeclaringType)); } } @@ -1691,7 +1756,26 @@ namespace ICSharpCode.Decompiler.CSharp return result; } } - var expr = ConvertField(inst.Field, inst.Target).WithILInstruction(inst); + TranslatedExpression expr; + if (TupleTransform.MatchTupleFieldAccess(inst, out IType underlyingTupleType, out var target, out int position)) { + var translatedTarget = TranslateTarget(target, + nonVirtualInvocation: true, + memberStatic: false, + memberDeclaringType: underlyingTupleType); + if (translatedTarget.Type is TupleType tupleType && tupleType.UnderlyingType.Equals(underlyingTupleType) && position <= tupleType.ElementNames.Length) { + string elementName = tupleType.ElementNames[position - 1]; + if (elementName == null) { + elementName = "Item" + position; + } + expr = new MemberReferenceExpression(translatedTarget, elementName) + .WithRR(new MemberResolveResult(translatedTarget.ResolveResult, inst.Field)) + .WithILInstruction(inst); + } else { + expr = ConvertField(inst.Field, inst.Target).WithILInstruction(inst); + } + } else { + expr = ConvertField(inst.Field, inst.Target).WithILInstruction(inst); + } if (inst.ResultType == StackType.I) { // ldflda producing native pointer return new UnaryOperatorExpression(UnaryOperatorType.AddressOf, expr) @@ -1699,7 +1783,7 @@ namespace ICSharpCode.Decompiler.CSharp } else { // ldflda producing managed pointer return new DirectionExpression(FieldDirection.Ref, expr) - .WithoutILInstruction().WithRR(new ByReferenceResolveResult(expr.Type, isOut: false)); + .WithoutILInstruction().WithRR(new ByReferenceResolveResult(expr.ResolveResult, isOut: false)); } } @@ -1714,7 +1798,7 @@ namespace ICSharpCode.Decompiler.CSharp { TranslatedExpression arrayExpr = Translate(inst.Array); var arrayType = arrayExpr.Type as ArrayType; - if (arrayType == null) { + if (arrayType == null || !TypeUtils.IsCompatibleTypeForMemoryAccess(new ByReferenceType(arrayType.ElementType), inst.Type)) { arrayType = new ArrayType(compilation, inst.Type, inst.Indices.Count); arrayExpr = arrayExpr.ConvertTo(arrayType, this); } @@ -1926,7 +2010,7 @@ namespace ICSharpCode.Decompiler.CSharp break; case IL.Transforms.AccessPathKind.Setter: if (lastElement.Indices?.Length > 0) { - var indexer = new IndexerExpression(null, lastElement.Indices.SelectArray(i => Translate(i is LdLoc ld ? indexVariables[ld.Variable] : i).Expression)) + var indexer = new IndexerExpression(null, lastElement.Indices.SelectArray(i => TranslateInitializerIndexerValue(i, indexVariables))) .WithILInstruction(inst).WithRR(memberRR); elementsStack.Peek().Add(Assignment(indexer, Translate(info.Values.Single(), typeHint: indexer.Type))); } else { @@ -1948,6 +2032,14 @@ namespace ICSharpCode.Decompiler.CSharp return expr.WithILInstruction(block); } + Expression TranslateInitializerIndexerValue(ILInstruction inst, Dictionary indexVariables) + { + if (inst is LdLoc ld && indexVariables.TryGetValue(ld.Variable, out var newInst)) { + inst = newInst; + } + return Translate(inst).Expression; + } + Expression MakeInitializerAssignment(IMember method, IL.Transforms.AccessPathElement member, List values, Dictionary indexVariables) { Expression value; diff --git a/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs b/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs index 0613a0030..1e471358b 100644 --- a/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs +++ b/ICSharpCode.Decompiler/CSharp/OutputVisitor/CSharpOutputVisitor.cs @@ -24,6 +24,7 @@ using System.Linq; using ICSharpCode.Decompiler.CSharp.Syntax; using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching; using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; using Attribute = ICSharpCode.Decompiler.CSharp.Syntax.Attribute; namespace ICSharpCode.Decompiler.CSharp.OutputVisitor @@ -444,6 +445,7 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor { foreach (CSharpModifierToken modifier in modifierTokens) { modifier.AcceptVisitor(this); + Space(); } } @@ -1061,7 +1063,17 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor throwExpression.Expression.AcceptVisitor(this); EndNode(throwExpression); } - + + public virtual void VisitTupleExpression(TupleExpression tupleExpression) + { + Debug.Assert(tupleExpression.Elements.Count >= 2); + StartNode(tupleExpression); + LPar(); + WriteCommaSeparatedList(tupleExpression.Elements); + RPar(); + EndNode(tupleExpression); + } + public virtual void VisitTypeOfExpression(TypeOfExpression typeOfExpression) { StartNode(typeOfExpression); @@ -2269,7 +2281,28 @@ namespace ICSharpCode.Decompiler.CSharp.OutputVisitor WriteTypeArguments(memberType.TypeArguments); EndNode(memberType); } - + + public virtual void VisitTupleType(TupleAstType tupleType) + { + Debug.Assert(tupleType.Elements.Count >= 2); + StartNode(tupleType); + LPar(); + WriteCommaSeparatedList(tupleType.Elements); + RPar(); + EndNode(tupleType); + } + + public virtual void VisitTupleTypeElement(TupleTypeElement tupleTypeElement) + { + StartNode(tupleTypeElement); + tupleTypeElement.Type.AcceptVisitor(this); + if (!tupleTypeElement.NameToken.IsNull) { + Space(); + tupleTypeElement.NameToken.AcceptVisitor(this); + } + EndNode(tupleTypeElement); + } + public virtual void VisitComposedType(ComposedType composedType) { StartNode(composedType); diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs index 35cbdc6c1..5d8860d36 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs @@ -19,6 +19,7 @@ using System; using System.Collections.Concurrent; using System.Collections.Generic; +using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using ICSharpCode.Decompiler.Semantics; @@ -37,15 +38,12 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver { readonly ConcurrentDictionary implicitConversionCache = new ConcurrentDictionary(); readonly ICompilation compilation; - readonly IType objectType; public CSharpConversions(ICompilation compilation) { if (compilation == null) throw new ArgumentNullException("compilation"); this.compilation = compilation; - this.objectType = compilation.FindType(KnownTypeCode.Object); - this.dynamicErasure = new DynamicErasure(this); } /// @@ -97,7 +95,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver #endregion #region ImplicitConversion - private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType, bool allowUserDefined) + private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType, bool allowUserDefined, bool allowTuple) { Conversion c; if (resolveResult.IsCompileTimeConstant) { @@ -105,18 +103,23 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (c.IsValid) return c; if (ImplicitConstantExpressionConversion(resolveResult, toType)) return Conversion.ImplicitConstantExpressionConversion; - c = StandardImplicitConversion(resolveResult.Type, toType); + c = StandardImplicitConversion(resolveResult.Type, toType, allowTuple); if (c != Conversion.None) return c; if (allowUserDefined) { c = UserDefinedImplicitConversion(resolveResult, resolveResult.Type, toType); if (c != Conversion.None) return c; } } else { - if (allowUserDefined) { - // if allowUserDefined is true, we might as well use the cache + if (allowTuple && resolveResult is TupleResolveResult tupleRR) { + c = TupleConversion(tupleRR, toType, isExplicit: false); + if (c != Conversion.None) + return c; + } + if (allowUserDefined && allowTuple) { + // if allowUserDefined and allowTuple are true, we might as well use the cache c = ImplicitConversion(resolveResult.Type, toType); } else { - c = ImplicitConversion(resolveResult.Type, toType, allowUserDefined); + c = ImplicitConversion(resolveResult.Type, toType, allowUserDefined, allowTuple); } if (c != Conversion.None) return c; } @@ -128,10 +131,10 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return c; } - private Conversion ImplicitConversion(IType fromType, IType toType, bool allowUserDefined) + private Conversion ImplicitConversion(IType fromType, IType toType, bool allowUserDefined, bool allowTuple) { // C# 4.0 spec: §6.1 - var c = StandardImplicitConversion(fromType, toType); + var c = StandardImplicitConversion(fromType, toType, allowTuple); if (c == Conversion.None && allowUserDefined) { c = UserDefinedImplicitConversion(null, fromType, toType); } @@ -142,7 +145,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver { if (resolveResult == null) throw new ArgumentNullException("resolveResult"); - return ImplicitConversion(resolveResult, toType, allowUserDefined: true); + return ImplicitConversion(resolveResult, toType, allowUserDefined: true, allowTuple: true); } public Conversion ImplicitConversion(IType fromType, IType toType) @@ -157,18 +160,23 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (implicitConversionCache.TryGetValue(pair, out c)) return c; - c = ImplicitConversion(fromType, toType, allowUserDefined: true); + c = ImplicitConversion(fromType, toType, allowUserDefined: true, allowTuple: true); implicitConversionCache[pair] = c; return c; } - + public Conversion StandardImplicitConversion(IType fromType, IType toType) { if (fromType == null) throw new ArgumentNullException("fromType"); if (toType == null) throw new ArgumentNullException("toType"); + return StandardImplicitConversion(fromType, toType, allowTupleConversion: true); + } + + Conversion StandardImplicitConversion(IType fromType, IType toType, bool allowTupleConversion) + { // C# 4.0 spec: §6.3.1 if (IdentityConversion(fromType, toType)) return Conversion.IdentityConversion; @@ -190,9 +198,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } if (ImplicitPointerConversion(fromType, toType)) return Conversion.ImplicitPointerConversion; + if (allowTupleConversion) { + c = TupleConversion(fromType, toType, isExplicit: false); + if (c != Conversion.None) + return c; + } return Conversion.None; } - + /// /// Gets whether the type 'fromType' is convertible to 'toType' /// using one of the conversions allowed when satisying constraints (§4.4.4) @@ -233,9 +246,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (resolveResult.Type.Kind == TypeKind.Dynamic) return Conversion.ExplicitDynamicConversion; - Conversion c = ImplicitConversion(resolveResult, toType, allowUserDefined: false); + Conversion c = ImplicitConversion(resolveResult, toType, allowUserDefined: false, allowTuple: false); if (c != Conversion.None) return c; + if (resolveResult is TupleResolveResult tupleRR) { + c = TupleConversion(tupleRR, toType, isExplicit: true); + if (c != Conversion.None) + return c; + } c = ExplicitConversionImpl(resolveResult.Type, toType); if (c != Conversion.None) return c; @@ -249,7 +267,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (toType == null) throw new ArgumentNullException("toType"); - Conversion c = ImplicitConversion(fromType, toType, allowUserDefined: false); + Conversion c = ImplicitConversion(fromType, toType, allowUserDefined: false, allowTuple: false); if (c != Conversion.None) return c; c = ExplicitConversionImpl(fromType, toType); @@ -278,10 +296,10 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return c; if (ExplicitPointerConversion(fromType, toType)) return Conversion.ExplicitPointerConversion; - return Conversion.None; + return TupleConversion(fromType, toType, isExplicit: true); } #endregion - + #region Identity Conversion /// /// Gets whether there is an identity conversion from to @@ -289,27 +307,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver public bool IdentityConversion(IType fromType, IType toType) { // C# 4.0 spec: §6.1.1 - return fromType.AcceptVisitor(dynamicErasure).Equals(toType.AcceptVisitor(dynamicErasure)); - } - - readonly DynamicErasure dynamicErasure; - - sealed class DynamicErasure : TypeVisitor - { - readonly IType objectType; - - public DynamicErasure(CSharpConversions conversions) - { - this.objectType = conversions.objectType; - } - - public override IType VisitOtherType(IType type) - { - if (type.Kind == TypeKind.Dynamic) - return objectType; - else - return base.VisitOtherType(type); - } + fromType = fromType.AcceptVisitor(NormalizeTypeVisitor.TypeErasure); + toType = toType.AcceptVisitor(NormalizeTypeVisitor.TypeErasure); + return fromType.Equals(toType); } #endregion @@ -494,7 +494,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver bool IsSubtypeOf(IType s, IType t, int subtypeCheckNestingDepth) { // conversion to dynamic + object are always possible - if (t.Kind == TypeKind.Dynamic || t.Equals(objectType)) + if (t.Kind == TypeKind.Dynamic || t.IsKnownType(KnownTypeCode.Object)) return true; if (subtypeCheckNestingDepth > 10) { // Subtyping in C# is undecidable @@ -856,7 +856,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver Conversion UserDefinedExplicitConversion(ResolveResult fromResult, IType fromType, IType toType) { - // C# 4.0 spec §6.4.5 User-defined implicit conversions + // C# 4.0 spec §6.4.5 User-defined explicit conversions var operators = GetApplicableConversionOperators(fromResult, fromType, toType, true); if (operators.Count > 0) { IType mostSpecificSource; @@ -1135,7 +1135,53 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver || IsImplicitReferenceConversion(m.ReturnType, invoke.ReturnType); } #endregion - + + #region Tuple Conversion + Conversion TupleConversion(TupleResolveResult fromRR, IType toType, bool isExplicit) + { + var fromElements = fromRR.Elements; + var toElements = TupleType.GetTupleElementTypes(toType); + if (toElements.IsDefault || fromElements.Length != toElements.Length) + return Conversion.None; + Conversion[] elementConversions = new Conversion[fromElements.Length]; + for (int i = 0; i < elementConversions.Length; i++) { + Conversion c; + if (isExplicit) { + c = ExplicitConversion(fromElements[i], toElements[i]); + } else { + c = ImplicitConversion(fromElements[i], toElements[i]); + } + if (!c.IsValid) + return Conversion.None; + elementConversions[i] = c; + } + return Conversion.TupleConversion(elementConversions.ToImmutableArray()); + } + + Conversion TupleConversion(IType fromType, IType toType, bool isExplicit) + { + var fromElements = TupleType.GetTupleElementTypes(fromType); + if (fromElements.IsDefaultOrEmpty) + return Conversion.None; + var toElements = TupleType.GetTupleElementTypes(toType); + if (toElements.IsDefault || fromElements.Length != toElements.Length) + return Conversion.None; + Conversion[] elementConversions = new Conversion[fromElements.Length]; + for (int i = 0; i < elementConversions.Length; i++) { + Conversion c; + if (isExplicit) { + c = ExplicitConversion(fromElements[i], toElements[i]); + } else { + c = ImplicitConversion(fromElements[i], toElements[i]); + } + if (!c.IsValid) + return Conversion.None; + elementConversions[i] = c; + } + return Conversion.TupleConversion(elementConversions.ToImmutableArray()); + } + #endregion + #region BetterConversion /// /// Gets the better conversion (C# 4.0 spec, §7.5.3.3) diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs index 304713e9b..aab64de06 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs @@ -255,6 +255,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver b.Append(')'); return b.ToString(); } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return this == obj; + } } #endregion @@ -1055,13 +1060,15 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver : base((IMethod)nonLiftedMethod.MemberDefinition, nonLiftedMethod.Substitution) { this.nonLiftedOperator = nonLiftedMethod; - var substitution = new MakeNullableVisitor(nonLiftedMethod.Compilation, nonLiftedMethod.Substitution); - this.Parameters = base.CreateParameters(substitution); + var compilation = nonLiftedMethod.Compilation; + var substitution = nonLiftedMethod.Substitution; + this.Parameters = base.CreateParameters( + type => NullableType.Create(compilation, type.AcceptVisitor(substitution))); // Comparison operators keep the 'bool' return type even when lifted. if (IsComparisonOperator(nonLiftedMethod)) this.ReturnType = nonLiftedMethod.ReturnType; else - this.ReturnType = nonLiftedMethod.ReturnType.AcceptVisitor(substitution); + this.ReturnType = NullableType.Create(compilation, nonLiftedMethod.ReturnType.AcceptVisitor(substitution)); } public IReadOnlyList NonLiftedParameters => nonLiftedOperator.Parameters; @@ -1078,38 +1085,6 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return nonLiftedOperator.GetHashCode() ^ 0x7191254; } } - - sealed class MakeNullableVisitor : TypeVisitor - { - readonly ICompilation compilation; - readonly TypeParameterSubstitution typeParameterSubstitution; - - public MakeNullableVisitor(ICompilation compilation, TypeParameterSubstitution typeParameterSubstitution) - { - this.compilation = compilation; - this.typeParameterSubstitution = typeParameterSubstitution; - } - - public override IType VisitTypeDefinition(ITypeDefinition type) - { - return NullableType.Create(compilation, type.AcceptVisitor(typeParameterSubstitution)); - } - - public override IType VisitTypeParameter(ITypeParameter type) - { - return NullableType.Create(compilation, type.AcceptVisitor(typeParameterSubstitution)); - } - - public override IType VisitParameterizedType(ParameterizedType type) - { - return NullableType.Create(compilation, type.AcceptVisitor(typeParameterSubstitution)); - } - - public override IType VisitOtherType(IType type) - { - return NullableType.Create(compilation, type.AcceptVisitor(typeParameterSubstitution)); - } - } #endregion } diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs index d6a176640..81384d5cd 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs @@ -1996,7 +1996,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } else { // argument might be a lambda or delegate type, so we have to try to guess the delegate type IType type = arguments[i].Type; - if (type.Kind == TypeKind.Null || type.Kind == TypeKind.Unknown) { + if (type.Kind == TypeKind.Null || type.Kind == TypeKind.None) { list.Add(new DefaultParameter(compilation.FindType(KnownTypeCode.Object), argumentNames[i])); } else { list.Add(new DefaultParameter(type, argumentNames[i])); @@ -2353,7 +2353,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver bool HasType(ResolveResult r) { - return r.Type.Kind != TypeKind.Unknown && r.Type.Kind != TypeKind.Null; + return r.Type.Kind != TypeKind.None && r.Type.Kind != TypeKind.Null; } #endregion diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/LambdaResolveResult.cs b/ICSharpCode.Decompiler/CSharp/Resolver/LambdaResolveResult.cs index b0c7c0bec..4dde321dd 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/LambdaResolveResult.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/LambdaResolveResult.cs @@ -30,7 +30,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver /// public abstract class LambdaResolveResult : ResolveResult { - protected LambdaResolveResult() : base(SpecialType.UnknownType) + protected LambdaResolveResult() : base(SpecialType.NoType) { } diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs b/ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs index 3ed5e526e..83207005d 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/MethodGroupResolveResult.cs @@ -83,7 +83,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver public MethodGroupResolveResult(ResolveResult targetResult, string methodName, IReadOnlyList methods, IReadOnlyList typeArguments) - : base(SpecialType.UnknownType) + : base(SpecialType.NoType) { if (methods == null) throw new ArgumentNullException("methods"); diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/ReducedExtensionMethod.cs b/ICSharpCode.Decompiler/CSharp/Resolver/ReducedExtensionMethod.cs index 2c4dc4241..cfcdb9517 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/ReducedExtensionMethod.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/ReducedExtensionMethod.cs @@ -45,6 +45,14 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver this.baseMethod = baseMethod; } + public bool Equals(IMember obj, TypeVisitor typeNormalization) + { + var other = obj as ReducedExtensionMethod; + if (other == null) + return false; + return baseMethod.Equals(other.baseMethod, typeNormalization); + } + public override bool Equals(object obj) { var other = obj as ReducedExtensionMethod; diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs b/ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs index e3f1dcac2..1dd855800 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/TypeInference.cs @@ -295,7 +295,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver static bool IsValidType(IType type) { - return type.Kind != TypeKind.Unknown && type.Kind != TypeKind.Null; + return type.Kind != TypeKind.Unknown && type.Kind != TypeKind.Null && type.Kind != TypeKind.None; } bool PhaseTwo() @@ -593,8 +593,8 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return; } // Handle parameterized type: - ParameterizedType pU = U as ParameterizedType; - ParameterizedType pV = V as ParameterizedType; + ParameterizedType pU = U.TupleUnderlyingTypeOrSelf() as ParameterizedType; + ParameterizedType pV = V.TupleUnderlyingTypeOrSelf() as ParameterizedType; if (pU != null && pV != null && object.Equals(pU.GenericType, pV.GenericType) && pU.TypeParameterCount == pV.TypeParameterCount) @@ -644,7 +644,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver // Handle array types: ArrayType arrU = U as ArrayType; ArrayType arrV = V as ArrayType; - ParameterizedType pV = V as ParameterizedType; + ParameterizedType pV = V.TupleUnderlyingTypeOrSelf() as ParameterizedType; if (arrU != null && arrV != null && arrU.Dimensions == arrV.Dimensions) { MakeLowerBoundInference(arrU.ElementType, arrV.ElementType); return; @@ -656,7 +656,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (pV != null) { ParameterizedType uniqueBaseType = null; foreach (IType baseU in U.GetAllBaseTypes()) { - ParameterizedType pU = baseU as ParameterizedType; + ParameterizedType pU = baseU.TupleUnderlyingTypeOrSelf() as ParameterizedType; if (pU != null && object.Equals(pU.GenericType, pV.GenericType) && pU.TypeParameterCount == pV.TypeParameterCount) { if (uniqueBaseType == null) uniqueBaseType = pU; @@ -730,7 +730,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver // Handle array types: ArrayType arrU = U as ArrayType; ArrayType arrV = V as ArrayType; - ParameterizedType pU = U as ParameterizedType; + ParameterizedType pU = U.TupleUnderlyingTypeOrSelf() as ParameterizedType; if (arrV != null && arrU != null && arrU.Dimensions == arrV.Dimensions) { MakeUpperBoundInference(arrU.ElementType, arrV.ElementType); return; @@ -742,7 +742,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (pU != null) { ParameterizedType uniqueBaseType = null; foreach (IType baseV in V.GetAllBaseTypes()) { - ParameterizedType pV = baseV as ParameterizedType; + ParameterizedType pV = baseV.TupleUnderlyingTypeOrSelf() as ParameterizedType; if (pV != null && object.Equals(pU.GenericType, pV.GenericType) && pU.TypeParameterCount == pV.TypeParameterCount) { if (uniqueBaseType == null) uniqueBaseType = pV; @@ -818,7 +818,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver if (expressions == null) throw new ArgumentNullException("expressions"); if (expressions.Count == 1) { - success = (expressions[0].Type.Kind != TypeKind.Unknown); + success = IsValidType(expressions[0].Type); return expressions[0].Type; } Log.WriteCollection("GetBestCommonType() for ", expressions); diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/DepthFirstAstVisitor.cs b/ICSharpCode.Decompiler/CSharp/Syntax/DepthFirstAstVisitor.cs index 043105b6f..44add8be6 100644 --- a/ICSharpCode.Decompiler/CSharp/Syntax/DepthFirstAstVisitor.cs +++ b/ICSharpCode.Decompiler/CSharp/Syntax/DepthFirstAstVisitor.cs @@ -115,7 +115,17 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax { VisitChildren (memberType); } - + + public virtual void VisitTupleType(TupleAstType tupleType) + { + VisitChildren(tupleType); + } + + public virtual void VisitTupleTypeElement(TupleTypeElement tupleTypeElement) + { + VisitChildren (tupleTypeElement); + } + public virtual void VisitAttribute (Attribute attribute) { VisitChildren (attribute); @@ -536,6 +546,11 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax VisitChildren (throwExpression); } + public virtual void VisitTupleExpression(TupleExpression tupleExpression) + { + VisitChildren (tupleExpression); + } + public virtual void VisitTypeOfExpression (TypeOfExpression typeOfExpression) { VisitChildren (typeOfExpression); @@ -747,7 +762,17 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax { return VisitChildren (memberType); } - + + public virtual T VisitTupleType(TupleAstType tupleType) + { + return VisitChildren (tupleType); + } + + public virtual T VisitTupleTypeElement(TupleTypeElement tupleTypeElement) + { + return VisitChildren (tupleTypeElement); + } + public virtual T VisitAttribute (Attribute attribute) { return VisitChildren (attribute); @@ -1168,6 +1193,11 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax return VisitChildren (throwExpression); } + public virtual T VisitTupleExpression (TupleExpression tupleExpression) + { + return VisitChildren (tupleExpression); + } + public virtual T VisitTypeOfExpression (TypeOfExpression typeOfExpression) { return VisitChildren (typeOfExpression); @@ -1379,7 +1409,17 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax { return VisitChildren (memberType, data); } - + + public virtual S VisitTupleType(TupleAstType tupleType, T data) + { + return VisitChildren (tupleType, data); + } + + public virtual S VisitTupleTypeElement(TupleTypeElement tupleTypeElement, T data) + { + return VisitChildren (tupleTypeElement, data); + } + public virtual S VisitAttribute (Attribute attribute, T data) { return VisitChildren (attribute, data); @@ -1800,6 +1840,11 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax return VisitChildren (throwExpression, data); } + public virtual S VisitTupleExpression (TupleExpression tupleExpression, T data) + { + return VisitChildren (tupleExpression, data); + } + public virtual S VisitTypeOfExpression (TypeOfExpression typeOfExpression, T data) { return VisitChildren (typeOfExpression, data); diff --git a/ICSharpCode.Decompiler/TypeSystem/ISolutionSnapshot.cs b/ICSharpCode.Decompiler/CSharp/Syntax/Expressions/TupleExpression.cs similarity index 56% rename from ICSharpCode.Decompiler/TypeSystem/ISolutionSnapshot.cs rename to ICSharpCode.Decompiler/CSharp/Syntax/Expressions/TupleExpression.cs index 99c964682..d6f75b93a 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ISolutionSnapshot.cs +++ b/ICSharpCode.Decompiler/CSharp/Syntax/Expressions/TupleExpression.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// Copyright (c) 2018 Daniel Grunwald // // Permission is hereby granted, free of charge, to any person obtaining a copy of this // software and associated documentation files (the "Software"), to deal in the Software @@ -16,26 +16,36 @@ // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. -namespace ICSharpCode.Decompiler.TypeSystem +using System; +using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching; + +namespace ICSharpCode.Decompiler.CSharp.Syntax { - /// - /// Represents a snapshot of the whole solution (multiple compilations). - /// - public interface ISolutionSnapshot + public class TupleExpression : Expression { - /// - /// Gets the project content with the specified file name. - /// Returns null if no such project exists in the solution. - /// - /// - /// This method is used by the class. - /// - IProjectContent GetProjectContent(string projectFileName); - - /// - /// Gets the compilation for the specified project. - /// The project must be a part of the solution (passed to the solution snapshot's constructor). - /// - ICompilation GetCompilation(IProjectContent project); + public AstNodeCollection Elements { + get { return GetChildrenByRole(Roles.Expression); } + } + + public override void AcceptVisitor(IAstVisitor visitor) + { + visitor.VisitTupleExpression(this); + } + + public override T AcceptVisitor(IAstVisitor visitor) + { + return visitor.VisitTupleExpression(this); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitTupleExpression(this, data); + } + + protected internal override bool DoMatch(AstNode other, Match match) + { + return other is TupleExpression tuple + && Elements.DoMatch(tuple.Elements, match); + } } } diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/IAstVisitor.cs b/ICSharpCode.Decompiler/CSharp/Syntax/IAstVisitor.cs index 24b8857a6..2d5bd8760 100644 --- a/ICSharpCode.Decompiler/CSharp/Syntax/IAstVisitor.cs +++ b/ICSharpCode.Decompiler/CSharp/Syntax/IAstVisitor.cs @@ -56,6 +56,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax void VisitStackAllocExpression(StackAllocExpression stackAllocExpression); void VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression); void VisitThrowExpression(ThrowExpression throwExpression); + void VisitTupleExpression(TupleExpression tupleExpression); void VisitTypeOfExpression(TypeOfExpression typeOfExpression); void VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression); void VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression); @@ -133,6 +134,8 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax void VisitSyntaxTree(SyntaxTree syntaxTree); void VisitSimpleType(SimpleType simpleType); void VisitMemberType(MemberType memberType); + void VisitTupleType(TupleAstType tupleType); + void VisitTupleTypeElement(TupleTypeElement tupleTypeElement); void VisitComposedType(ComposedType composedType); void VisitArraySpecifier(ArraySpecifier arraySpecifier); void VisitPrimitiveType(PrimitiveType primitiveType); @@ -194,6 +197,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax S VisitStackAllocExpression(StackAllocExpression stackAllocExpression); S VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression); S VisitThrowExpression(ThrowExpression throwExpression); + S VisitTupleExpression(TupleExpression tupleExpression); S VisitTypeOfExpression(TypeOfExpression typeOfExpression); S VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression); S VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression); @@ -271,6 +275,8 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax S VisitSyntaxTree(SyntaxTree syntaxTree); S VisitSimpleType(SimpleType simpleType); S VisitMemberType(MemberType memberType); + S VisitTupleType(TupleAstType tupleType); + S VisitTupleTypeElement(TupleTypeElement tupleTypeElement); S VisitComposedType(ComposedType composedType); S VisitArraySpecifier(ArraySpecifier arraySpecifier); S VisitPrimitiveType(PrimitiveType primitiveType); @@ -332,6 +338,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax S VisitStackAllocExpression(StackAllocExpression stackAllocExpression, T data); S VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, T data); S VisitThrowExpression(ThrowExpression throwExpression, T data); + S VisitTupleExpression(TupleExpression tupleExpression, T data); S VisitTypeOfExpression(TypeOfExpression typeOfExpression, T data); S VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, T data); S VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, T data); @@ -409,6 +416,8 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax S VisitSyntaxTree(SyntaxTree syntaxTree, T data); S VisitSimpleType(SimpleType simpleType, T data); S VisitMemberType(MemberType memberType, T data); + S VisitTupleType(TupleAstType tupleType, T data); + S VisitTupleTypeElement(TupleTypeElement tupleTypeElement, T data); S VisitComposedType(ComposedType composedType, T data); S VisitArraySpecifier(ArraySpecifier arraySpecifier, T data); S VisitPrimitiveType(PrimitiveType primitiveType, T data); diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Backreference.cs b/ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Backreference.cs index 845dd6123..d3d8c3e93 100644 --- a/ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Backreference.cs +++ b/ICSharpCode.Decompiler/CSharp/Syntax/PatternMatching/Backreference.cs @@ -41,7 +41,7 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching public override bool DoMatch(INode other, Match match) { - var last = match.Get (referencedGroupName).Last (); + var last = match.Get (referencedGroupName).LastOrDefault(); if (last == null && other == null) return true; return last.IsMatch(other); diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/TupleAstType.cs b/ICSharpCode.Decompiler/CSharp/Syntax/TupleAstType.cs new file mode 100644 index 000000000..4a34830aa --- /dev/null +++ b/ICSharpCode.Decompiler/CSharp/Syntax/TupleAstType.cs @@ -0,0 +1,139 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Linq; +using ICSharpCode.Decompiler.CSharp.Resolver; +using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.CSharp.Syntax +{ + public class TupleAstType : AstType + { + public static readonly Role ElementRole = new Role("Element", TupleTypeElement.Null); + + public AstNodeCollection Elements { + get { return GetChildrenByRole(ElementRole); } + } + + public override void AcceptVisitor(IAstVisitor visitor) + { + visitor.VisitTupleType(this); + } + + public override T AcceptVisitor(IAstVisitor visitor) + { + return visitor.VisitTupleType(this); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitTupleType(this, data); + } + + public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null) + { + return new TupleTypeReference( + this.Elements.Select(e => e.Type.ToTypeReference(lookupMode, interningProvider)).ToImmutableArray(), + this.Elements.Select(e => e.Name).ToImmutableArray() + ); + } + + protected internal override bool DoMatch(AstNode other, Match match) + { + return other is TupleAstType o && Elements.DoMatch(o.Elements, match); + } + } + + public class TupleTypeElement : AstNode + { + #region Null + public new static readonly TupleTypeElement Null = new TupleTypeElement(); + + sealed class NullTupleTypeElement : TupleTypeElement + { + public override bool IsNull { + get { + return true; + } + } + + public override void AcceptVisitor(IAstVisitor visitor) + { + visitor.VisitNullNode(this); + } + + public override T AcceptVisitor(IAstVisitor visitor) + { + return visitor.VisitNullNode(this); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitNullNode(this, data); + } + + protected internal override bool DoMatch(AstNode other, PatternMatching.Match match) + { + return other == null || other.IsNull; + } + } + #endregion + + public AstType Type { + get { return GetChildByRole(Roles.Type); } + set { SetChildByRole(Roles.Type, value); } + } + + public string Name { + get { return GetChildByRole(Roles.Identifier).Name; } + set { SetChildByRole(Roles.Identifier, Identifier.Create(value)); } + } + + public Identifier NameToken { + get { return GetChildByRole(Roles.Identifier); } + set { SetChildByRole(Roles.Identifier, value); } + } + + public override NodeType NodeType => NodeType.Unknown; + + public override void AcceptVisitor(IAstVisitor visitor) + { + visitor.VisitTupleTypeElement(this); + } + + public override T AcceptVisitor(IAstVisitor visitor) + { + return visitor.VisitTupleTypeElement(this); + } + + public override S AcceptVisitor(IAstVisitor visitor, T data) + { + return visitor.VisitTupleTypeElement(this, data); + } + + protected internal override bool DoMatch(AstNode other, Match match) + { + return other is TupleTypeElement o + && Type.DoMatch(o.Type, match) + && MatchString(Name, o.Name); + } + } +} diff --git a/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs b/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs index 49c6372cf..cca707708 100644 --- a/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs +++ b/ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs @@ -231,15 +231,23 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax return ConvertType(typeWithElementType.ElementType); } } - ParameterizedType pt = type as ParameterizedType; - if (pt != null) { + if (type is ParameterizedType pt) { if (pt.IsKnownType(KnownTypeCode.NullableOfT)) { return ConvertType(pt.TypeArguments[0]).MakeNullableType(); } return ConvertTypeHelper(pt.GenericType, pt.TypeArguments); } - ITypeDefinition typeDef = type as ITypeDefinition; - if (typeDef != null) { + if (type is TupleType tuple) { + var astType = new TupleAstType(); + foreach (var (etype, ename) in tuple.ElementTypes.Zip(tuple.ElementNames)) { + astType.Elements.Add(new TupleTypeElement { + Type = ConvertType(etype), + Name = ename + }); + } + return astType; + } + if (type is ITypeDefinition typeDef) { if (typeDef.TypeParameterCount > 0) { // Unbound type IType[] typeArguments = new IType[typeDef.TypeParameterCount]; @@ -430,7 +438,10 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax attr.Arguments.Add(ConvertConstantValue(arg)); } foreach (var pair in attribute.NamedArguments) { - attr.Arguments.Add(new NamedExpression(pair.Key.Name, ConvertConstantValue(pair.Value))); + NamedExpression namedArgument = new NamedExpression(pair.Key.Name, ConvertConstantValue(pair.Value)); + if (AddResolveResultAnnotations) + namedArgument.AddAnnotation(new MemberResolveResult(new InitializedObjectResolveResult(attribute.AttributeType), pair.Key)); + attr.Arguments.Add(namedArgument); } return attr; } @@ -660,8 +671,12 @@ namespace ICSharpCode.Decompiler.CSharp.Syntax ITypeDefinition enumDefinition = type.GetDefinition(); TypeCode enumBaseTypeCode = ReflectionHelper.GetTypeCode(enumDefinition.EnumUnderlyingType); foreach (IField field in enumDefinition.Fields) { - if (field.IsConst && object.Equals(CSharpPrimitiveCast.Cast(TypeCode.Int64, field.ConstantValue, false), val)) - return new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name); + if (field.IsConst && object.Equals(CSharpPrimitiveCast.Cast(TypeCode.Int64, field.ConstantValue, false), val)) { + MemberReferenceExpression mre = new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name); + if (AddResolveResultAnnotations) + mre.AddAnnotation(new MemberResolveResult(mre.Target.GetResolveResult(), field)); + return mre; + } } if (IsFlagsEnum(enumDefinition)) { long enumValue = val; diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/AddCheckedBlocks.cs b/ICSharpCode.Decompiler/CSharp/Transforms/AddCheckedBlocks.cs index 856c648ce..0ce8a0bde 100644 --- a/ICSharpCode.Decompiler/CSharp/Transforms/AddCheckedBlocks.cs +++ b/ICSharpCode.Decompiler/CSharp/Transforms/AddCheckedBlocks.cs @@ -16,6 +16,7 @@ // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +using System; using System.Linq; using ICSharpCode.Decompiler.CSharp.Syntax; @@ -107,6 +108,22 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms { return string.Format("[{0} + {1}]", Blocks, Expressions); } + + /// + /// Gets the new cost if an expression with this cost is wrapped in a checked/unchecked expression. + /// + /// + internal Cost WrapInCheckedExpr() + { + if (Expressions == 0) { + return new Cost(Blocks, 1); + } else { + // hack: penalize multiple layers of nested expressions + // This doesn't really fit into the original idea of minimizing the number of block+expressions; + // but tends to produce better-looking results due to less nesting. + return new Cost(Blocks, Expressions + 2); + } + } } #endregion @@ -324,11 +341,13 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms // We cannot use checked/unchecked for top-level-expressions. } else if (expr.Role.IsValid(Expression.Null)) { // We use '<' so that expressions are introduced on the deepest level possible (goal 3) - if (result.CostInCheckedContext + new Cost(0, 1) < result.CostInUncheckedContext) { - result.CostInUncheckedContext = result.CostInCheckedContext + new Cost(0, 1); + var costIfWrapWithChecked = result.CostInCheckedContext.WrapInCheckedExpr(); + var costIfWrapWithUnchecked = result.CostInUncheckedContext.WrapInCheckedExpr(); + if (costIfWrapWithChecked < result.CostInUncheckedContext) { + result.CostInUncheckedContext = costIfWrapWithChecked; result.NodesToInsertInUncheckedContext = result.NodesToInsertInCheckedContext + new InsertedExpression(expr, true); - } else if (result.CostInUncheckedContext + new Cost(0, 1) < result.CostInCheckedContext) { - result.CostInCheckedContext = result.CostInUncheckedContext + new Cost(0, 1); + } else if (costIfWrapWithUnchecked < result.CostInCheckedContext) { + result.CostInCheckedContext = costIfWrapWithUnchecked; result.NodesToInsertInCheckedContext = result.NodesToInsertInUncheckedContext + new InsertedExpression(expr, false); } } diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs b/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs index e99e0af87..f4c0c61d9 100644 --- a/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs +++ b/ICSharpCode.Decompiler/CSharp/Transforms/PatternStatementTransform.cs @@ -257,6 +257,8 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms var indexVariable = m.Get("indexVariable").Single().GetILVariable(); var arrayVariable = m.Get("arrayVariable").Single().GetILVariable(); var loopContainer = forStatement.Annotation(); + if (itemVariable == null || indexVariable == null || arrayVariable == null) + return null; if (!itemVariable.IsSingleDefinition || (itemVariable.CaptureScope != null && itemVariable.CaptureScope != loopContainer)) return null; if (indexVariable.StoreCount != 2 || indexVariable.LoadCount != 3 || indexVariable.AddressCount != 0) @@ -391,7 +393,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms if (!m.Success) break; if (upperBounds == null) { collection = m.Get("collection").Single().GetILVariable(); - if (!(collection.Type is Decompiler.TypeSystem.ArrayType arrayType)) + if (!(collection?.Type is Decompiler.TypeSystem.ArrayType arrayType)) break; upperBounds = new IL.ILVariable[arrayType.Dimensions]; } else { @@ -414,7 +416,7 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms statementsToDelete.Add(stmt); statementsToDelete.Add(stmt.GetNextStatement()); var itemVariable = foreachVariable.GetILVariable(); - if (!itemVariable.IsSingleDefinition + if (itemVariable == null || !itemVariable.IsSingleDefinition || !upperBounds.All(ub => ub.IsSingleDefinition && ub.LoadCount == 1) || !lowerBounds.All(lb => lb.StoreCount == 2 && lb.LoadCount == 3 && lb.AddressCount == 0)) return null; @@ -509,6 +511,18 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms RemoveCompilerGeneratedAttribute(property.Setter.Attributes); property.Getter.Body = null; property.Setter.Body = null; + + // Add C# 7.3 attributes on backing field: + var attributes = fieldInfo.Attributes + .Where(a => !attributeTypesToRemoveFromAutoProperties.Any(t => t == a.AttributeType.FullName)) + .Select(context.TypeSystemAstBuilder.ConvertAttribute).ToArray(); + if (attributes.Length > 0) { + var section = new AttributeSection { + AttributeTarget = "field" + }; + section.Attributes.AddRange(attributes); + property.Attributes.Add(section); + } } // Since the property instance is not changed, we can continue in the visitor as usual, so return null return null; @@ -668,10 +682,10 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms Left = new IdentifierExpressionBackreference("var1"), Right = new InvocationExpression(new MemberReferenceExpression(new TypeReferenceExpression(new TypePattern(typeof(System.Threading.Interlocked)).ToType()), "CompareExchange", - new AstType[] { new AnyNode("type") }), // type argument+ + new AstType[] { new Repeat(new AnyNode()) }), // optional type arguments new Expression[] { // arguments new DirectionExpression { FieldDirection = FieldDirection.Ref, Expression = new Backreference("field") }, - new CastExpression(new Backreference("type"), new InvocationExpression(new AnyNode("delegateCombine").ToExpression(), new IdentifierExpressionBackreference("var2"), new IdentifierExpression("value"))), + new CastExpression(new AnyNode("type"), new InvocationExpression(new AnyNode("delegateCombine").ToExpression(), new IdentifierExpressionBackreference("var2"), new IdentifierExpression("value"))), new IdentifierExpressionBackreference("var1") } ) @@ -706,6 +720,11 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms "System.Runtime.CompilerServices.MethodImplAttribute" }; + static readonly string[] attributeTypesToRemoveFromAutoProperties = new[] { + "System.Runtime.CompilerServices.CompilerGeneratedAttribute", + "System.Diagnostics.DebuggerBrowsableAttribute" + }; + bool CheckAutomaticEventV4(CustomEventDeclaration ev, out Match addMatch, out Match removeMatch) { addMatch = removeMatch = default(Match); diff --git a/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs b/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs index f72e2994f..fc18a8442 100644 --- a/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs +++ b/ICSharpCode.Decompiler/CSharp/Transforms/PrettifyAssignments.cs @@ -16,9 +16,12 @@ // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +using System; using System.Linq; using ICSharpCode.Decompiler.CSharp.Syntax; using ICSharpCode.Decompiler.CSharp.Syntax.PatternMatching; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.CSharp.Transforms { @@ -52,9 +55,10 @@ namespace ICSharpCode.Decompiler.CSharp.Transforms // TODO: context.Settings.IntroduceIncrementAndDecrement if (assignment.Operator == AssignmentOperatorType.Add || assignment.Operator == AssignmentOperatorType.Subtract) { // detect increment/decrement - if (assignment.Right.IsMatch(new PrimitiveExpression(1))) { + var rr = assignment.Right.GetResolveResult(); + if (rr.IsCompileTimeConstant && rr.Type.IsCSharpPrimitiveIntegerType() && CSharpPrimitiveCast.Cast(rr.Type.GetTypeCode(), 1, false).Equals(rr.ConstantValue)) { // only if it's not a custom operator - if (assignment.Annotation() == null) { + if (assignment.Annotation() == null && assignment.Annotation() == null) { UnaryOperatorType type; // When the parent is an expression statement, pre- or post-increment doesn't matter; // so we can pick post-increment which is more commonly used (for (int i = 0; i < x; i++)) diff --git a/ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs b/ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs index 694fb6de5..5ebd40771 100644 --- a/ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs +++ b/ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs @@ -18,6 +18,7 @@ using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using ICSharpCode.Decompiler.CSharp.Syntax; @@ -25,6 +26,7 @@ using ICSharpCode.Decompiler.CSharp.Transforms; using ICSharpCode.Decompiler.IL; using ICSharpCode.Decompiler.Semantics; using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.CSharp { @@ -198,9 +200,32 @@ namespace ICSharpCode.Decompiler.CSharp } return this; } - if (targetType.Kind == TypeKind.Unknown || targetType.Kind == TypeKind.Void) { + if (targetType.Kind == TypeKind.Unknown || targetType.Kind == TypeKind.Void || targetType.Kind == TypeKind.None) { return this; // don't attempt to insert cast to '?' or 'void' as these are not valid. } + if (Expression is TupleExpression tupleExpr && targetType is TupleType targetTupleType + && tupleExpr.Elements.Count == targetTupleType.ElementTypes.Length) + { + // Conversion of a tuple literal: convert element-wise + var newTupleExpr = new TupleExpression(); + var newElementRRs = new List(); + foreach (var (elementExpr, elementTargetType) in tupleExpr.Elements.Zip(targetTupleType.ElementTypes)) { + var newElementExpr = new TranslatedExpression(elementExpr.Detach()) + .ConvertTo(elementTargetType, expressionBuilder, checkForOverflow, allowImplicitConversion); + newTupleExpr.Elements.Add(newElementExpr.Expression); + newElementRRs.Add(newElementExpr.ResolveResult); + } + return newTupleExpr.WithILInstruction(this.ILInstructions) + .WithRR(new TupleResolveResult(expressionBuilder.compilation, newElementRRs.ToImmutableArray())); + } + var compilation = expressionBuilder.compilation; + var conversions = Resolver.CSharpConversions.Get(compilation); + if (ResolveResult is ConversionResolveResult conv && Expression is CastExpression cast2 && conv.Conversion.IsBoxingConversion && conversions.IsBoxingConversion(conv.Input.Type, targetType)) { + var unwrapped = this.UnwrapChild(cast2.Expression); + if (allowImplicitConversion) + return unwrapped; + return unwrapped.ConvertTo(targetType, expressionBuilder, checkForOverflow, allowImplicitConversion); + } if (Expression is UnaryOperatorExpression uoe && uoe.Operator == UnaryOperatorType.NullConditional && targetType.IsReferenceType == true) { // "(T)(x?).AccessChain" is invalid, but "((T)x)?.AccessChain" is valid and equivalent return new UnaryOperatorExpression( @@ -208,7 +233,6 @@ namespace ICSharpCode.Decompiler.CSharp UnwrapChild(uoe.Expression).ConvertTo(targetType, expressionBuilder, checkForOverflow, allowImplicitConversion) ).WithRR(new ResolveResult(targetType)).WithoutILInstruction(); } - var compilation = expressionBuilder.compilation; bool isLifted = type.IsKnownType(KnownTypeCode.NullableOfT) && targetType.IsKnownType(KnownTypeCode.NullableOfT); IType utype = isLifted ? NullableType.GetUnderlyingType(type) : type; IType targetUType = isLifted ? NullableType.GetUnderlyingType(targetType) : targetType; @@ -350,8 +374,7 @@ namespace ICSharpCode.Decompiler.CSharp .WithILInstruction(this.ILInstructions) .WithRR(new ConstantResolveResult(targetType, null)); } - var conversions = Resolver.CSharpConversions.Get(compilation); - if (allowImplicitConversion && conversions.ImplicitConversion(type, targetType).IsValid) { + if (allowImplicitConversion && conversions.ImplicitConversion(ResolveResult, targetType).IsValid) { return this; } var castExpr = new CastExpression(expressionBuilder.ConvertType(targetType), Expression); diff --git a/ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs b/ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs index f6c834320..7a7303a7e 100644 --- a/ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs +++ b/ICSharpCode.Decompiler/CSharp/TypeSystem/AliasNamespaceReference.cs @@ -54,7 +54,7 @@ namespace ICSharpCode.Decompiler.CSharp.TypeSystem public override IType ResolveType(CSharpResolver resolver) { // alias cannot refer to types - return SpecialType.UnknownType; + return SpecialType.NoType; } public override string ToString() diff --git a/ICSharpCode.Decompiler/CSharp/TypeSystem/ConstantValues.cs b/ICSharpCode.Decompiler/CSharp/TypeSystem/ConstantValues.cs deleted file mode 100644 index 2e2e18fbd..000000000 --- a/ICSharpCode.Decompiler/CSharp/TypeSystem/ConstantValues.cs +++ /dev/null @@ -1,519 +0,0 @@ -// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team -// -// Permission is hereby granted, free of charge, to any person obtaining a copy of this -// software and associated documentation files (the "Software"), to deal in the Software -// without restriction, including without limitation the rights to use, copy, modify, merge, -// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons -// to whom the Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all copies or -// substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, -// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE -// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -using System; -using System.Collections.Generic; -using ICSharpCode.Decompiler.CSharp.Resolver; -using ICSharpCode.Decompiler.CSharp.Syntax; -using ICSharpCode.Decompiler.Semantics; -using ICSharpCode.Decompiler.TypeSystem; -using ICSharpCode.Decompiler.Util; - -namespace ICSharpCode.Decompiler.CSharp.TypeSystem -{ - // Contains representations for constant C# expressions. - // We use these instead of storing the full AST to reduce the memory usage. - - [Serializable] - public abstract class ConstantExpression : IConstantValue - { - public abstract ResolveResult Resolve(CSharpResolver resolver); - - public ResolveResult Resolve(ITypeResolveContext context) - { - var csContext = (CSharpTypeResolveContext)context; - if (context.CurrentAssembly != context.Compilation.MainAssembly) { - // The constant needs to be resolved in a different compilation. - IProjectContent pc = context.CurrentAssembly as IProjectContent; - if (pc != null) { - ICompilation nestedCompilation = context.Compilation.SolutionSnapshot.GetCompilation(pc); - if (nestedCompilation != null) { - var nestedContext = MapToNestedCompilation(csContext, nestedCompilation); - ResolveResult rr = Resolve(new CSharpResolver(nestedContext)); - return MapToNewContext(rr, context); - } - } - } - // Resolve in current context. - return Resolve(new CSharpResolver(csContext)); - } - - CSharpTypeResolveContext MapToNestedCompilation(CSharpTypeResolveContext context, ICompilation nestedCompilation) - { - var nestedContext = new CSharpTypeResolveContext(nestedCompilation.MainAssembly); - if (context.CurrentUsingScope != null) { - nestedContext = nestedContext.WithUsingScope(context.CurrentUsingScope.UnresolvedUsingScope.Resolve(nestedCompilation)); - } - if (context.CurrentTypeDefinition != null) { - nestedContext = nestedContext.WithCurrentTypeDefinition(nestedCompilation.Import(context.CurrentTypeDefinition)); - } - return nestedContext; - } - - static ResolveResult MapToNewContext(ResolveResult rr, ITypeResolveContext newContext) - { - if (rr is TypeOfResolveResult) { - return new TypeOfResolveResult( - rr.Type.ToTypeReference().Resolve(newContext), - ((TypeOfResolveResult)rr).ReferencedType.ToTypeReference().Resolve(newContext)); - } else if (rr is ArrayCreateResolveResult) { - ArrayCreateResolveResult acrr = (ArrayCreateResolveResult)rr; - return new ArrayCreateResolveResult( - acrr.Type.ToTypeReference().Resolve(newContext), - MapToNewContext(acrr.SizeArguments, newContext), - MapToNewContext(acrr.InitializerElements, newContext)); - } else if (rr.IsCompileTimeConstant) { - return new ConstantResolveResult( - rr.Type.ToTypeReference().Resolve(newContext), - rr.ConstantValue - ); - } else { - return new ErrorResolveResult(rr.Type.ToTypeReference().Resolve(newContext)); - } - } - - static ResolveResult[] MapToNewContext(IList input, ITypeResolveContext newContext) - { - if (input == null) - return null; - ResolveResult[] output = new ResolveResult[input.Count]; - for (int i = 0; i < output.Length; i++) { - output[i] = MapToNewContext(input[i], newContext); - } - return output; - } - } - - /// - /// Used for constants that could not be converted to IConstantValue. - /// - [Serializable] - public sealed class ErrorConstantValue : IConstantValue - { - readonly ITypeReference type; - - public ErrorConstantValue(ITypeReference type) - { - if (type == null) - throw new ArgumentNullException("type"); - this.type = type; - } - - public ResolveResult Resolve(ITypeResolveContext context) - { - return new ErrorResolveResult(type.Resolve(context)); - } - } - - /// - /// Increments an integer by a fixed amount without changing the type. - /// - [Serializable] - public sealed class IncrementConstantValue : IConstantValue, ISupportsInterning - { - readonly IConstantValue baseValue; - readonly int incrementAmount; - - public IncrementConstantValue(IConstantValue baseValue, int incrementAmount = 1) - { - if (baseValue == null) - throw new ArgumentNullException("baseValue"); - IncrementConstantValue icv = baseValue as IncrementConstantValue; - if (icv != null) { - this.baseValue = icv.baseValue; - this.incrementAmount = icv.incrementAmount + incrementAmount; - } else { - this.baseValue = baseValue; - this.incrementAmount = incrementAmount; - } - } - - public ResolveResult Resolve(ITypeResolveContext context) - { - ResolveResult rr = baseValue.Resolve(context); - if (rr.IsCompileTimeConstant && rr.ConstantValue != null) { - object val = rr.ConstantValue; - TypeCode typeCode = Type.GetTypeCode(val.GetType()); - if (typeCode >= TypeCode.SByte && typeCode <= TypeCode.UInt64) { - long intVal = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, val, false); - object newVal = CSharpPrimitiveCast.Cast(typeCode, unchecked(intVal + incrementAmount), false); - return new ConstantResolveResult(rr.Type, newVal); - } - } - return new ErrorResolveResult(rr.Type); - } - - int ISupportsInterning.GetHashCodeForInterning() - { - unchecked { - return baseValue.GetHashCode() * 33 ^ incrementAmount; - } - } - - bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) - { - IncrementConstantValue o = other as IncrementConstantValue; - return o != null && baseValue == o.baseValue && incrementAmount == o.incrementAmount; - } - } - - /// - /// C#'s equivalent to the SimpleConstantValue. - /// - [Serializable] - public sealed class PrimitiveConstantExpression : ConstantExpression, ISupportsInterning - { - readonly ITypeReference type; - readonly object value; - - public ITypeReference Type { - get { return type; } - } - - public object Value { - get { return value; } - } - - public PrimitiveConstantExpression(ITypeReference type, object value) - { - if (type == null) - throw new ArgumentNullException("type"); - this.type = type; - this.value = value; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return new ConstantResolveResult(type.Resolve(resolver.CurrentTypeResolveContext), value); - } - - int ISupportsInterning.GetHashCodeForInterning() - { - return type.GetHashCode() ^ (value != null ? value.GetHashCode() : 0); - } - - bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) - { - PrimitiveConstantExpression scv = other as PrimitiveConstantExpression; - return scv != null && type == scv.type && value == scv.value; - } - } - - [Serializable] - public sealed class TypeOfConstantExpression : ConstantExpression - { - readonly ITypeReference type; - - public ITypeReference Type { - get { return type; } - } - - public TypeOfConstantExpression(ITypeReference type) - { - this.type = type; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveTypeOf(type.Resolve(resolver.CurrentTypeResolveContext)); - } - } - - [Serializable] - public sealed class ConstantCast : ConstantExpression, ISupportsInterning - { - readonly ITypeReference targetType; - readonly ConstantExpression expression; - readonly bool allowNullableConstants; - - public ConstantCast(ITypeReference targetType, ConstantExpression expression, bool allowNullableConstants) - { - if (targetType == null) - throw new ArgumentNullException("targetType"); - if (expression == null) - throw new ArgumentNullException("expression"); - this.targetType = targetType; - this.expression = expression; - this.allowNullableConstants = allowNullableConstants; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - var type = targetType.Resolve(resolver.CurrentTypeResolveContext); - var resolveResult = expression.Resolve(resolver); - if (allowNullableConstants && NullableType.IsNullable(type)) { - resolveResult = resolver.ResolveCast(NullableType.GetUnderlyingType(type), resolveResult); - if (resolveResult.IsCompileTimeConstant) - return new ConstantResolveResult(type, resolveResult.ConstantValue); - } - return resolver.ResolveCast(type, resolveResult); - } - - int ISupportsInterning.GetHashCodeForInterning() - { - unchecked { - return targetType.GetHashCode() + expression.GetHashCode() * 1018829; - } - } - - bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) - { - ConstantCast cast = other as ConstantCast; - return cast != null - && this.targetType == cast.targetType && this.expression == cast.expression && this.allowNullableConstants == cast.allowNullableConstants; - } - } - - [Serializable] - public sealed class ConstantIdentifierReference : ConstantExpression - { - readonly string identifier; - readonly IList typeArguments; - - public ConstantIdentifierReference(string identifier, IList typeArguments = null) - { - if (identifier == null) - throw new ArgumentNullException("identifier"); - this.identifier = identifier; - this.typeArguments = typeArguments ?? EmptyList.Instance; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveSimpleName(identifier, typeArguments.Resolve(resolver.CurrentTypeResolveContext)); - } - } - - [Serializable] - public sealed class ConstantMemberReference : ConstantExpression - { - readonly ITypeReference targetType; - readonly ConstantExpression targetExpression; - readonly string memberName; - readonly IList typeArguments; - - public ConstantMemberReference(ITypeReference targetType, string memberName, IList typeArguments = null) - { - if (targetType == null) - throw new ArgumentNullException("targetType"); - if (memberName == null) - throw new ArgumentNullException("memberName"); - this.targetType = targetType; - this.memberName = memberName; - this.typeArguments = typeArguments ?? EmptyList.Instance; - } - - public ConstantMemberReference(ConstantExpression targetExpression, string memberName, IList typeArguments = null) - { - if (targetExpression == null) - throw new ArgumentNullException("targetExpression"); - if (memberName == null) - throw new ArgumentNullException("memberName"); - this.targetExpression = targetExpression; - this.memberName = memberName; - this.typeArguments = typeArguments ?? EmptyList.Instance; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - ResolveResult rr; - if (targetType != null) - rr = new TypeResolveResult(targetType.Resolve(resolver.CurrentTypeResolveContext)); - else - rr = targetExpression.Resolve(resolver); - return resolver.ResolveMemberAccess(rr, memberName, typeArguments.Resolve(resolver.CurrentTypeResolveContext)); - } - } - - [Serializable] - public sealed class ConstantCheckedExpression : ConstantExpression - { - readonly bool checkForOverflow; - readonly ConstantExpression expression; - - public ConstantCheckedExpression(bool checkForOverflow, ConstantExpression expression) - { - if (expression == null) - throw new ArgumentNullException("expression"); - this.checkForOverflow = checkForOverflow; - this.expression = expression; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return expression.Resolve(resolver.WithCheckForOverflow(checkForOverflow)); - } - } - - [Serializable] - public sealed class ConstantDefaultValue : ConstantExpression, ISupportsInterning - { - readonly ITypeReference type; - - public ConstantDefaultValue(ITypeReference type) - { - if (type == null) - throw new ArgumentNullException("type"); - this.type = type; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveDefaultValue(type.Resolve(resolver.CurrentTypeResolveContext)); - } - - int ISupportsInterning.GetHashCodeForInterning() - { - return type.GetHashCode(); - } - - bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) - { - ConstantDefaultValue o = other as ConstantDefaultValue; - return o != null && this.type == o.type; - } - } - - [Serializable] - public sealed class ConstantUnaryOperator : ConstantExpression - { - readonly UnaryOperatorType operatorType; - readonly ConstantExpression expression; - - public ConstantUnaryOperator(UnaryOperatorType operatorType, ConstantExpression expression) - { - if (expression == null) - throw new ArgumentNullException("expression"); - this.operatorType = operatorType; - this.expression = expression; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveUnaryOperator(operatorType, expression.Resolve(resolver)); - } - } - - [Serializable] - public sealed class ConstantBinaryOperator : ConstantExpression - { - readonly ConstantExpression left; - readonly BinaryOperatorType operatorType; - readonly ConstantExpression right; - - public ConstantBinaryOperator(ConstantExpression left, BinaryOperatorType operatorType, ConstantExpression right) - { - if (left == null) - throw new ArgumentNullException("left"); - if (right == null) - throw new ArgumentNullException("right"); - this.left = left; - this.operatorType = operatorType; - this.right = right; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - ResolveResult lhs = left.Resolve(resolver); - ResolveResult rhs = right.Resolve(resolver); - return resolver.ResolveBinaryOperator(operatorType, lhs, rhs); - } - } - - [Serializable] - public sealed class ConstantConditionalOperator : ConstantExpression - { - readonly ConstantExpression condition, trueExpr, falseExpr; - - public ConstantConditionalOperator(ConstantExpression condition, ConstantExpression trueExpr, ConstantExpression falseExpr) - { - if (condition == null) - throw new ArgumentNullException("condition"); - if (trueExpr == null) - throw new ArgumentNullException("trueExpr"); - if (falseExpr == null) - throw new ArgumentNullException("falseExpr"); - this.condition = condition; - this.trueExpr = trueExpr; - this.falseExpr = falseExpr; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveConditional( - condition.Resolve(resolver), - trueExpr.Resolve(resolver), - falseExpr.Resolve(resolver) - ); - } - } - - /// - /// Represents an array creation (as used within an attribute argument) - /// - [Serializable] - public sealed class ConstantArrayCreation : ConstantExpression - { - // type may be null when the element is being inferred - readonly ITypeReference elementType; - readonly IList arrayElements; - - public ConstantArrayCreation(ITypeReference type, IList arrayElements) - { - if (arrayElements == null) - throw new ArgumentNullException("arrayElements"); - this.elementType = type; - this.arrayElements = arrayElements; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - ResolveResult[] elements = new ResolveResult[arrayElements.Count]; - for (int i = 0; i < elements.Length; i++) { - elements[i] = arrayElements[i].Resolve(resolver); - } - int[] sizeArguments = { elements.Length }; - if (elementType != null) { - return resolver.ResolveArrayCreation(elementType.Resolve(resolver.CurrentTypeResolveContext), sizeArguments, elements); - } else { - return resolver.ResolveArrayCreation(null, sizeArguments, elements); - } - } - } - - /// - /// Used for sizeof() expressions in constants. - /// - [Serializable] - public sealed class SizeOfConstantValue : ConstantExpression - { - readonly ITypeReference type; - - public SizeOfConstantValue(ITypeReference type) - { - if (type == null) - throw new ArgumentNullException("type"); - this.type = type; - } - - public override ResolveResult Resolve(CSharpResolver resolver) - { - return resolver.ResolveSizeOf(type.Resolve(resolver.CurrentTypeResolveContext)); - } - } -} diff --git a/ICSharpCode.Decompiler/DecompilerSettings.cs b/ICSharpCode.Decompiler/DecompilerSettings.cs index 45dd53dc9..d48c2ef88 100644 --- a/ICSharpCode.Decompiler/DecompilerSettings.cs +++ b/ICSharpCode.Decompiler/DecompilerSettings.cs @@ -59,7 +59,7 @@ namespace ICSharpCode.Decompiler expressionTrees = false; } if (languageVersion < CSharp.LanguageVersion.CSharp4) { - dynamicExpressions = false; + dynamic = false; // * named and optional arguments (not supported yet) } if (languageVersion < CSharp.LanguageVersion.CSharp5) { @@ -74,11 +74,17 @@ namespace ICSharpCode.Decompiler } if (languageVersion < CSharp.LanguageVersion.CSharp7) { outVariables = false; + tupleTypes = false; + tupleConversions = false; discards = false; } if (languageVersion < CSharp.LanguageVersion.CSharp7_2) { introduceRefAndReadonlyModifiersOnStructs = false; } + if (languageVersion < CSharp.LanguageVersion.CSharp7_3) { + //introduceUnmanagedTypeConstraint = false; + tupleComparisons = false; + } } bool anonymousMethods = true; @@ -141,6 +147,21 @@ namespace ICSharpCode.Decompiler } } + bool dynamic = true; + + /// + /// Decompile use of the 'dynamic' type. + /// + public bool Dynamic { + get { return dynamic; } + set { + if (dynamic != value) { + dynamic = value; + OnPropertyChanged(); + } + } + } + bool asyncAwait = true; /// @@ -582,6 +603,53 @@ namespace ICSharpCode.Decompiler } } + bool tupleTypes = true; + + /// + /// Gets/Sets whether tuple type syntax (int, string) + /// should be used for System.ValueTuple. + /// + public bool TupleTypes { + get { return tupleTypes; } + set { + if (tupleTypes != value) { + tupleTypes = value; + OnPropertyChanged(); + } + } + } + + bool tupleConversions = true; + + /// + /// Gets/Sets whether implicit conversions between tuples + /// should be used in the decompiled output. + /// + public bool TupleConversions { + get { return tupleConversions; } + set { + if (tupleConversions != value) { + tupleConversions = value; + OnPropertyChanged(); + } + } + } + + bool tupleComparisons = true; + + /// + /// Gets/Sets whether tuple comparisons should be detected. + /// + public bool TupleComparisons { + get { return tupleComparisons; } + set { + if (tupleComparisons != value) { + tupleComparisons = value; + OnPropertyChanged(); + } + } + } + #region Options to aid VB decompilation bool assumeArrayLengthFitsIntoInt32 = true; diff --git a/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonSerializationException.cs b/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonSerializationException.cs deleted file mode 100644 index 829d6b30c..000000000 --- a/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonSerializationException.cs +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. - -namespace LightJson.Serialization -{ - using System; - - /// - /// The exception that is thrown when a JSON value cannot be serialized. - /// - /// - /// This exception is only intended to be thrown by LightJson. - /// - internal sealed class JsonSerializationException : Exception - { - /// - /// Initializes a new instance of the class. - /// - public JsonSerializationException() - : base(GetDefaultMessage(ErrorType.Unknown)) - { - } - - /// - /// Initializes a new instance of the class with the given error type. - /// - /// The error type that describes the cause of the error. - public JsonSerializationException(ErrorType type) - : this(GetDefaultMessage(type), type) - { - } - - /// - /// Initializes a new instance of the class with the given message and - /// error type. - /// - /// The message that describes the error. - /// The error type that describes the cause of the error. - public JsonSerializationException(string message, ErrorType type) - : base(message) - { - this.Type = type; - } - - /// - /// Enumerates the types of errors that can occur during serialization. - /// - public enum ErrorType - { - /// - /// Indicates that the cause of the error is unknown. - /// - Unknown = 0, - - /// - /// Indicates that the writer encountered an invalid number value (NAN, infinity) during serialization. - /// - InvalidNumber, - - /// - /// Indicates that the object been serialized contains an invalid JSON value type. - /// That is, a value type that is not null, boolean, number, string, object, or array. - /// - InvalidValueType, - - /// - /// Indicates that the object been serialized contains a circular reference. - /// - CircularReference, - } - - /// - /// Gets the type of error that caused the exception to be thrown. - /// - /// - /// The type of error that caused the exception to be thrown. - /// - public ErrorType Type { get; } - - private static string GetDefaultMessage(ErrorType type) - { - switch (type) { - case ErrorType.InvalidNumber: - return "The value been serialized contains an invalid number value (NAN, infinity)."; - - case ErrorType.InvalidValueType: - return "The value been serialized contains (or is) an invalid JSON type."; - - case ErrorType.CircularReference: - return "The value been serialized contains circular references."; - - default: - return "An error occurred during serialization."; - } - } - } -} diff --git a/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonWriter.cs b/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonWriter.cs deleted file mode 100644 index f1e1fb0c8..000000000 --- a/ICSharpCode.Decompiler/DotNetCore/LightJson/Serialization/JsonWriter.cs +++ /dev/null @@ -1,349 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. - -namespace LightJson.Serialization -{ - using System; - using System.Collections.Generic; - using System.Diagnostics; - using System.Globalization; - using System.IO; - using ErrorType = JsonSerializationException.ErrorType; - - /// - /// Represents a writer that can write string representations of JsonValues. - /// - internal sealed class JsonWriter : IDisposable - { - private int indent; - private bool isNewLine; - private TextWriter writer; - - /// - /// A set of containing all the collection objects (JsonObject/JsonArray) being rendered. - /// It is used to prevent circular references; since collections that contain themselves - /// will never finish rendering. - /// - private HashSet> renderingCollections; - - /// - /// Initializes a new instance of the class. - /// - public JsonWriter() - : this(false) - { - } - - /// - /// Initializes a new instance of the class. - /// - /// - /// A value indicating whether the output of the writer should be human-readable. - /// - public JsonWriter(bool pretty) - { - if (pretty) { - this.IndentString = "\t"; - this.SpacingString = " "; - this.NewLineString = "\n"; - } - } - - /// - /// Gets or sets the string representing a indent in the output. - /// - /// - /// The string representing a indent in the output. - /// - public string IndentString { get; set; } - - /// - /// Gets or sets the string representing a space in the output. - /// - /// - /// The string representing a space in the output. - /// - public string SpacingString { get; set; } - - /// - /// Gets or sets the string representing a new line on the output. - /// - /// - /// The string representing a new line on the output. - /// - public string NewLineString { get; set; } - - /// - /// Gets or sets a value indicating whether JsonObject properties should be written in a deterministic order. - /// - /// - /// A value indicating whether JsonObject properties should be written in a deterministic order. - /// - public bool SortObjects { get; set; } - - /// - /// Returns a string representation of the given JsonValue. - /// - /// The JsonValue to serialize. - /// The serialized value. - public string Serialize(JsonValue jsonValue) - { - this.Initialize(); - - this.Render(jsonValue); - - return this.writer.ToString(); - } - - /// - /// Releases all the resources used by this object. - /// - public void Dispose() - { - if (this.writer != null) { - this.writer.Dispose(); - } - } - - private static bool IsValidNumber(double number) - { - return !(double.IsNaN(number) || double.IsInfinity(number)); - } - - private void Initialize() - { - this.indent = 0; - this.isNewLine = true; - this.writer = new StringWriter(); - this.renderingCollections = new HashSet>(); - } - - private void Write(string text) - { - if (this.isNewLine) { - this.isNewLine = false; - this.WriteIndentation(); - } - - this.writer.Write(text); - } - - private void WriteEncodedJsonValue(JsonValue value) - { - switch (value.Type) { - case JsonValueType.Null: - this.Write("null"); - break; - - case JsonValueType.Boolean: - this.Write(value.AsString); - break; - - case JsonValueType.Number: - this.Write(((double)value).ToString(CultureInfo.InvariantCulture)); - break; - - default: - Debug.Assert(value.Type == JsonValueType.String, "value.Type == JsonValueType.String"); - this.WriteEncodedString((string)value); - break; - } - } - - private void WriteEncodedString(string text) - { - this.Write("\""); - - for (int i = 0; i < text.Length; i += 1) { - var currentChar = text[i]; - - // Encoding special characters. - switch (currentChar) { - case '\\': - this.writer.Write("\\\\"); - break; - - case '\"': - this.writer.Write("\\\""); - break; - - case '/': - this.writer.Write("\\/"); - break; - - case '\b': - this.writer.Write("\\b"); - break; - - case '\f': - this.writer.Write("\\f"); - break; - - case '\n': - this.writer.Write("\\n"); - break; - - case '\r': - this.writer.Write("\\r"); - break; - - case '\t': - this.writer.Write("\\t"); - break; - - default: - this.writer.Write(currentChar); - break; - } - } - - this.writer.Write("\""); - } - - private void WriteIndentation() - { - for (var i = 0; i < this.indent; i += 1) { - this.Write(this.IndentString); - } - } - - private void WriteSpacing() - { - this.Write(this.SpacingString); - } - - private void WriteLine() - { - this.Write(this.NewLineString); - this.isNewLine = true; - } - - private void WriteLine(string line) - { - this.Write(line); - this.WriteLine(); - } - - private void AddRenderingCollection(IEnumerable value) - { - if (!this.renderingCollections.Add(value)) { - throw new JsonSerializationException(ErrorType.CircularReference); - } - } - - private void RemoveRenderingCollection(IEnumerable value) - { - this.renderingCollections.Remove(value); - } - - private void Render(JsonValue value) - { - switch (value.Type) { - case JsonValueType.Null: - case JsonValueType.Boolean: - case JsonValueType.Number: - case JsonValueType.String: - this.WriteEncodedJsonValue(value); - break; - - case JsonValueType.Object: - this.Render((JsonObject)value); - break; - - case JsonValueType.Array: - this.Render((JsonArray)value); - break; - - default: - throw new JsonSerializationException(ErrorType.InvalidValueType); - } - } - - private void Render(JsonArray value) - { - this.AddRenderingCollection(value); - - this.WriteLine("["); - - this.indent += 1; - - using (var enumerator = value.GetEnumerator()) { - var hasNext = enumerator.MoveNext(); - - while (hasNext) { - this.Render(enumerator.Current); - - hasNext = enumerator.MoveNext(); - - if (hasNext) { - this.WriteLine(","); - } else { - this.WriteLine(); - } - } - } - - this.indent -= 1; - - this.Write("]"); - - this.RemoveRenderingCollection(value); - } - - private void Render(JsonObject value) - { - this.AddRenderingCollection(value); - - this.WriteLine("{"); - - this.indent += 1; - - using (var enumerator = this.GetJsonObjectEnumerator(value)) { - var hasNext = enumerator.MoveNext(); - - while (hasNext) { - this.WriteEncodedString(enumerator.Current.Key); - this.Write(":"); - this.WriteSpacing(); - this.Render(enumerator.Current.Value); - - hasNext = enumerator.MoveNext(); - - if (hasNext) { - this.WriteLine(","); - } else { - this.WriteLine(); - } - } - } - - this.indent -= 1; - - this.Write("}"); - - this.RemoveRenderingCollection(value); - } - - /// - /// Gets an JsonObject enumerator based on the configuration of this JsonWriter. - /// If JsonWriter.SortObjects is set to true, then a ordered enumerator is returned. - /// Otherwise, a faster non-deterministic enumerator is returned. - /// - /// The JsonObject for which to get an enumerator. - /// An enumerator for the properties in a . - private IEnumerator> GetJsonObjectEnumerator(JsonObject jsonObject) - { - if (this.SortObjects) { - var sortedDictionary = new SortedDictionary(StringComparer.Ordinal); - - foreach (var item in jsonObject) { - sortedDictionary.Add(item.Key, item.Value); - } - - return sortedDictionary.GetEnumerator(); - } else { - return jsonObject.GetEnumerator(); - } - } - } -} diff --git a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj index 1066e146e..cacda3343 100644 --- a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj +++ b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj @@ -107,6 +107,7 @@ + @@ -178,6 +179,7 @@ + @@ -234,7 +236,6 @@ - @@ -280,8 +281,6 @@ - - @@ -306,6 +305,7 @@ + @@ -326,6 +326,9 @@ + + + @@ -441,7 +444,6 @@ - @@ -516,9 +518,7 @@ - - diff --git a/ICSharpCode.Decompiler/IL/ControlFlow/ExitPoints.cs b/ICSharpCode.Decompiler/IL/ControlFlow/ExitPoints.cs index 460903996..0c7e9532b 100644 --- a/ICSharpCode.Decompiler/IL/ControlFlow/ExitPoints.cs +++ b/ICSharpCode.Decompiler/IL/ControlFlow/ExitPoints.cs @@ -119,13 +119,32 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow /// List potentialExits; + readonly List blocksPotentiallyMadeUnreachable = new List(); + public void Run(ILFunction function, ILTransformContext context) { cancellationToken = context.CancellationToken; currentExit = NoExit; + blocksPotentiallyMadeUnreachable.Clear(); function.AcceptVisitor(this); + // It's possible that there are unreachable code blocks which we only + // detect as such during exit point detection. + // Clean them up. + foreach (var block in blocksPotentiallyMadeUnreachable) { + if (block.IncomingEdgeCount == 0 || block.IncomingEdgeCount == 1 && IsInfiniteLoop(block)) { + block.Remove(); + } + } + blocksPotentiallyMadeUnreachable.Clear(); } - + + static bool IsInfiniteLoop(Block block) + { + return block.Instructions.Count == 1 + && block.Instructions[0] is Branch b + && b.TargetBlock == block; + } + protected override void Default(ILInstruction inst) { foreach (var child in inst.Children) @@ -157,7 +176,17 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow while (inst.Parent.OpCode != OpCode.Block) inst = inst.Parent; Block block = (Block)inst.Parent; - block.Instructions.Add(currentExit); + if (block.HasFlag(InstructionFlags.EndPointUnreachable)) { + // Special case: despite replacing the exits with leave(currentContainer), + // we still have an unreachable endpoint. + // The appended currentExit instruction would not be reachable! + // This happens in test case ExceptionHandling.ThrowInFinally() + if (currentExit is Branch b) { + blocksPotentiallyMadeUnreachable.Add(b.TargetBlock); + } + } else { + block.Instructions.Add(currentExit); + } } else { Debug.Assert(thisExit == currentExit); } diff --git a/ICSharpCode.Decompiler/IL/ILTypeExtensions.cs b/ICSharpCode.Decompiler/IL/ILTypeExtensions.cs index fcdecef8e..a6b5d94fd 100644 --- a/ICSharpCode.Decompiler/IL/ILTypeExtensions.cs +++ b/ICSharpCode.Decompiler/IL/ILTypeExtensions.cs @@ -163,6 +163,14 @@ namespace ICSharpCode.Decompiler.IL return new TypeSystem.ByReferenceType(ldflda.Field.Type); case LdsFlda ldsflda: return new TypeSystem.ByReferenceType(ldsflda.Field.Type); + case LdElema ldelema: + if (ldelema.Array.InferType() is TypeSystem.ArrayType arrayType) { + var refType = new TypeSystem.ByReferenceType(arrayType.ElementType); + if (TypeUtils.IsCompatibleTypeForMemoryAccess(refType, ldelema.Type)) { + return refType; + } + } + return new TypeSystem.ByReferenceType(ldelema.Type); default: return SpecialType.UnknownType; } diff --git a/ICSharpCode.Decompiler/IL/Instructions.cs b/ICSharpCode.Decompiler/IL/Instructions.cs index 019fe26ce..cefff257e 100644 --- a/ICSharpCode.Decompiler/IL/Instructions.cs +++ b/ICSharpCode.Decompiler/IL/Instructions.cs @@ -45,8 +45,10 @@ namespace ICSharpCode.Decompiler.IL PinnedRegion, /// Common instruction for add, sub, mul, div, rem, bit.and, bit.or, bit.xor, shl and shr. BinaryNumericInstruction, - /// Common instruction for compound assignments. - CompoundAssignmentInstruction, + /// Common instruction for numeric compound assignments. + NumericCompoundAssign, + /// Common instruction for user-defined compound assignments. + UserDefinedCompoundAssign, /// Bitwise NOT BitNot, /// Retrieves the RuntimeArgumentHandle. @@ -527,6 +529,96 @@ namespace ICSharpCode.Decompiler.IL.Patterns } } namespace ICSharpCode.Decompiler.IL +{ + /// Common instruction for compound assignments. + public abstract partial class CompoundAssignmentInstruction : ILInstruction + { + public static readonly SlotInfo TargetSlot = new SlotInfo("Target", canInlineInto: true); + ILInstruction target; + public ILInstruction Target { + get { return this.target; } + set { + ValidateChild(value); + SetChildInstruction(ref this.target, value, 0); + } + } + public static readonly SlotInfo ValueSlot = new SlotInfo("Value", canInlineInto: true); + ILInstruction value; + public ILInstruction Value { + get { return this.value; } + set { + ValidateChild(value); + SetChildInstruction(ref this.value, value, 1); + } + } + protected sealed override int GetChildCount() + { + return 2; + } + protected sealed override ILInstruction GetChild(int index) + { + switch (index) { + case 0: + return this.target; + case 1: + return this.value; + default: + throw new IndexOutOfRangeException(); + } + } + protected sealed override void SetChild(int index, ILInstruction value) + { + switch (index) { + case 0: + this.Target = value; + break; + case 1: + this.Value = value; + break; + default: + throw new IndexOutOfRangeException(); + } + } + protected sealed override SlotInfo GetChildSlot(int index) + { + switch (index) { + case 0: + return TargetSlot; + case 1: + return ValueSlot; + default: + throw new IndexOutOfRangeException(); + } + } + public sealed override ILInstruction Clone() + { + var clone = (CompoundAssignmentInstruction)ShallowClone(); + clone.Target = this.target.Clone(); + clone.Value = this.value.Clone(); + return clone; + } + protected override InstructionFlags ComputeFlags() + { + return target.Flags | value.Flags; + } + public override InstructionFlags DirectFlags { + get { + return InstructionFlags.None; + } + } + public override void WriteTo(ITextOutput output, ILAstWritingOptions options) + { + ILRange.WriteTo(output, options); + output.Write(OpCode); + output.Write('('); + this.target.WriteTo(output, options); + output.Write(", "); + this.value.WriteTo(output, options); + output.Write(')'); + } + } +} +namespace ICSharpCode.Decompiler.IL { /// Represents invalid IL. Semantically, this instruction is considered to throw some kind of exception. public sealed partial class InvalidBranch : SimpleInstruction @@ -933,96 +1025,66 @@ namespace ICSharpCode.Decompiler.IL } namespace ICSharpCode.Decompiler.IL { - /// Common instruction for compound assignments. - public sealed partial class CompoundAssignmentInstruction : ILInstruction + /// Common instruction for numeric compound assignments. + public sealed partial class NumericCompoundAssign : CompoundAssignmentInstruction { - public static readonly SlotInfo TargetSlot = new SlotInfo("Target", canInlineInto: true); - ILInstruction target; - public ILInstruction Target { - get { return this.target; } - set { - ValidateChild(value); - SetChildInstruction(ref this.target, value, 0); - } - } - public static readonly SlotInfo ValueSlot = new SlotInfo("Value", canInlineInto: true); - ILInstruction value; - public ILInstruction Value { - get { return this.value; } - set { - ValidateChild(value); - SetChildInstruction(ref this.value, value, 1); - } + IType type; + /// Returns the type operand. + public IType Type { + get { return type; } + set { type = value; InvalidateFlags(); } } - protected sealed override int GetChildCount() + public override StackType ResultType { get { return type.GetStackType(); } } + public override void AcceptVisitor(ILVisitor visitor) { - return 2; + visitor.VisitNumericCompoundAssign(this); } - protected sealed override ILInstruction GetChild(int index) + public override T AcceptVisitor(ILVisitor visitor) { - switch (index) { - case 0: - return this.target; - case 1: - return this.value; - default: - throw new IndexOutOfRangeException(); - } + return visitor.VisitNumericCompoundAssign(this); } - protected sealed override void SetChild(int index, ILInstruction value) + public override T AcceptVisitor(ILVisitor visitor, C context) { - switch (index) { - case 0: - this.Target = value; - break; - case 1: - this.Value = value; - break; - default: - throw new IndexOutOfRangeException(); - } + return visitor.VisitNumericCompoundAssign(this, context); } - protected sealed override SlotInfo GetChildSlot(int index) + protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match) { - switch (index) { - case 0: - return TargetSlot; - case 1: - return ValueSlot; - default: - throw new IndexOutOfRangeException(); - } + var o = other as NumericCompoundAssign; + return o != null && type.Equals(o.type) && CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match); } - public sealed override ILInstruction Clone() + } +} +namespace ICSharpCode.Decompiler.IL +{ + /// Common instruction for user-defined compound assignments. + public sealed partial class UserDefinedCompoundAssign : CompoundAssignmentInstruction + { + + protected override InstructionFlags ComputeFlags() { - var clone = (CompoundAssignmentInstruction)ShallowClone(); - clone.Target = this.target.Clone(); - clone.Value = this.value.Clone(); - return clone; + return base.ComputeFlags() | InstructionFlags.MayThrow | InstructionFlags.SideEffect; } - IType type; - /// Returns the type operand. - public IType Type { - get { return type; } - set { type = value; InvalidateFlags(); } + public override InstructionFlags DirectFlags { + get { + return base.DirectFlags | InstructionFlags.MayThrow | InstructionFlags.SideEffect; + } } - public override StackType ResultType { get { return type.GetStackType(); } } public override void AcceptVisitor(ILVisitor visitor) { - visitor.VisitCompoundAssignmentInstruction(this); + visitor.VisitUserDefinedCompoundAssign(this); } public override T AcceptVisitor(ILVisitor visitor) { - return visitor.VisitCompoundAssignmentInstruction(this); + return visitor.VisitUserDefinedCompoundAssign(this); } public override T AcceptVisitor(ILVisitor visitor, C context) { - return visitor.VisitCompoundAssignmentInstruction(this, context); + return visitor.VisitUserDefinedCompoundAssign(this, context); } protected internal override bool PerformMatch(ILInstruction other, ref Patterns.Match match) { - var o = other as CompoundAssignmentInstruction; - return o != null && this.target.PerformMatch(o.target, ref match) && this.value.PerformMatch(o.value, ref match) && type.Equals(o.type) && CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator; + var o = other as UserDefinedCompoundAssign; + return o != null && this.Method.Equals(o.Method) && this.CompoundAssignmentType == o.CompoundAssignmentType && Target.PerformMatch(o.Target, ref match) && Value.PerformMatch(o.Value, ref match); } } } @@ -6021,7 +6083,11 @@ namespace ICSharpCode.Decompiler.IL { Default(inst); } - protected internal virtual void VisitCompoundAssignmentInstruction(CompoundAssignmentInstruction inst) + protected internal virtual void VisitNumericCompoundAssign(NumericCompoundAssign inst) + { + Default(inst); + } + protected internal virtual void VisitUserDefinedCompoundAssign(UserDefinedCompoundAssign inst) { Default(inst); } @@ -6383,7 +6449,11 @@ namespace ICSharpCode.Decompiler.IL { return Default(inst); } - protected internal virtual T VisitCompoundAssignmentInstruction(CompoundAssignmentInstruction inst) + protected internal virtual T VisitNumericCompoundAssign(NumericCompoundAssign inst) + { + return Default(inst); + } + protected internal virtual T VisitUserDefinedCompoundAssign(UserDefinedCompoundAssign inst) { return Default(inst); } @@ -6745,7 +6815,11 @@ namespace ICSharpCode.Decompiler.IL { return Default(inst, context); } - protected internal virtual T VisitCompoundAssignmentInstruction(CompoundAssignmentInstruction inst, C context) + protected internal virtual T VisitNumericCompoundAssign(NumericCompoundAssign inst, C context) + { + return Default(inst, context); + } + protected internal virtual T VisitUserDefinedCompoundAssign(UserDefinedCompoundAssign inst, C context) { return Default(inst, context); } @@ -7078,7 +7152,8 @@ namespace ICSharpCode.Decompiler.IL "Block", "PinnedRegion", "binary", - "compound", + "numeric.compound", + "user.compound", "bit.not", "arglist", "br", diff --git a/ICSharpCode.Decompiler/IL/Instructions.tt b/ICSharpCode.Decompiler/IL/Instructions.tt index 6f75055ff..a5d031b43 100644 --- a/ICSharpCode.Decompiler/IL/Instructions.tt +++ b/ICSharpCode.Decompiler/IL/Instructions.tt @@ -33,9 +33,11 @@ new OpCode("CallInstruction", "Instruction with a list of arguments.", AbstractBaseClass, CustomChildren(new []{ new ArgumentInfo("arguments") { IsCollection = true }}), CustomWriteTo, MayThrow, SideEffect), + new OpCode("PatternInstruction", "Base class for pattern matching in ILAst.", AbstractBaseClass, ResultType("Unknown")) { Namespace = "ICSharpCode.Decompiler.IL.Patterns" }, + new OpCode("CompoundAssignmentInstruction", "Common instruction for compound assignments.", + AbstractBaseClass, CustomConstructor, CustomArguments(("target", null), ("value", null))), new OpCode("DynamicInstruction", "Instruction representing a dynamic call site.", - AbstractBaseClass, CustomWriteTo, MayThrow, SideEffect), - new OpCode("PatternInstruction", "Base class for pattern matching in ILAst.", AbstractBaseClass, ResultType("Unknown")) { Namespace = "ICSharpCode.Decompiler.IL.Patterns" } + AbstractBaseClass, CustomWriteTo, MayThrow, SideEffect) }; OpCode[] opCodes = { @@ -68,10 +70,19 @@ new OpCode("binary", "Common instruction for add, sub, mul, div, rem, bit.and, bit.or, bit.xor, shl and shr.", CustomClassName("BinaryNumericInstruction"), Binary, CustomWriteTo, CustomConstructor, CustomComputeFlags, MatchCondition("CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator && IsLifted == o.IsLifted")), - new OpCode("compound", "Common instruction for compound assignments.", - CustomClassName("CompoundAssignmentInstruction"), CustomConstructor, CustomComputeFlags, - MayThrow, CustomArguments(("target", null), ("value", null)), HasTypeOperand, ResultType("type.GetStackType()"), CustomWriteTo, - MatchCondition("CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator")), + new OpCode("numeric.compound", "Common instruction for numeric compound assignments.", + CustomClassName("NumericCompoundAssign"), BaseClass("CompoundAssignmentInstruction"), CustomConstructor, CustomComputeFlags, + MayThrow, HasTypeOperand, ResultType("type.GetStackType()"), CustomWriteTo, + MatchCondition("CheckForOverflow == o.CheckForOverflow && Sign == o.Sign && Operator == o.Operator"), + MatchCondition("Target.PerformMatch(o.Target, ref match)"), + MatchCondition("Value.PerformMatch(o.Value, ref match)")), + new OpCode("user.compound", "Common instruction for user-defined compound assignments.", + CustomClassName("UserDefinedCompoundAssign"), BaseClass("CompoundAssignmentInstruction"), CustomConstructor, + MayThrow, SideEffect, CustomWriteTo, + MatchCondition("this.Method.Equals(o.Method)"), + MatchCondition("this.CompoundAssignmentType == o.CompoundAssignmentType"), + MatchCondition("Target.PerformMatch(o.Target, ref match)"), + MatchCondition("Value.PerformMatch(o.Value, ref match)")), new OpCode("bit.not", "Bitwise NOT", Unary, CustomConstructor, MatchCondition("IsLifted == o.IsLifted && UnderlyingResultType == o.UnderlyingResultType")), new OpCode("arglist", "Retrieves the RuntimeArgumentHandle.", NoArguments, ResultType("O")), new OpCode("br", "Unconditional branch. goto target;", diff --git a/ICSharpCode.Decompiler/IL/Instructions/BinaryNumericInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/BinaryNumericInstruction.cs index 0910a5017..7ea3d754e 100644 --- a/ICSharpCode.Decompiler/IL/Instructions/BinaryNumericInstruction.cs +++ b/ICSharpCode.Decompiler/IL/Instructions/BinaryNumericInstruction.cs @@ -148,7 +148,7 @@ namespace ICSharpCode.Decompiler.IL } } - string GetOperatorName(BinaryNumericOperator @operator) + internal static string GetOperatorName(BinaryNumericOperator @operator) { switch (@operator) { case BinaryNumericOperator.Add: diff --git a/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs index 8eff8c227..4ee19cb8a 100644 --- a/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs +++ b/ICSharpCode.Decompiler/IL/Instructions/CallInstruction.cs @@ -18,8 +18,10 @@ using System; using System.Diagnostics; +using System.Linq; using ICSharpCode.Decompiler.Disassembler; using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.IL { @@ -58,10 +60,21 @@ namespace ICSharpCode.Decompiler.IL /// public bool ILStackWasEmpty; + /// + /// Gets the mapping of arguments to method parameters. Must be a 1-to-1 mapping. + /// Normally this is index == value for static calls and newobj, and value + 1 == index for instance method calls. + /// |ArgumentToParameterMap| == |Arguments|. + /// + public int[] ArgumentToParameterMap; + protected CallInstruction(OpCode opCode, IMethod method) : base(opCode) { Debug.Assert(method != null); this.Method = method; + int firstParameter = OpCode != OpCode.NewObj && !Method.IsStatic ? 1 : 0; + this.ArgumentToParameterMap = new int[method.Parameters.Count + firstParameter]; + for (int i = 0; i < ArgumentToParameterMap.Length; i++) + ArgumentToParameterMap[i] = -firstParameter + i; this.Arguments = new InstructionCollection(this, 0); } @@ -113,13 +126,24 @@ namespace ICSharpCode.Decompiler.IL base.CheckInvariant(phase); int firstArgument = (OpCode != OpCode.NewObj && !Method.IsStatic) ? 1 : 0; Debug.Assert(Method.Parameters.Count + firstArgument == Arguments.Count); + Debug.Assert(Method.Parameters.Count + firstArgument == ArgumentToParameterMap.Length); if (firstArgument == 1) { Debug.Assert(Arguments[0].ResultType == ExpectedTypeForThisPointer(ConstrainedTo ?? Method.DeclaringType), $"Stack type mismatch in 'this' argument in call to {Method.Name}()"); + Debug.Assert(ArgumentToParameterMap[0] == -1, "'this' argument must always be mapped at position 0"); } - for (int i = 0; i < Method.Parameters.Count; ++i) { - Debug.Assert(Arguments[firstArgument + i].ResultType == Method.Parameters[i].Type.GetStackType(), - $"Stack type mismatch in parameter {i} in call to {Method.Name}()"); + int paramCount = Method.Parameters.Count; + if (paramCount > 0) { + BitSet bitSet = new BitSet(paramCount); + for (int i = 0; i < paramCount; ++i) { + int mappedTo = ArgumentToParameterMap[firstArgument + i]; + Debug.Assert(mappedTo >= 0 && mappedTo < paramCount, $"mapping out of [0..{paramCount}[, was: {mappedTo}"); + Debug.Assert(!bitSet[mappedTo], $"argument {mappedTo} is already mapped to a different parameter"); + bitSet.Set(mappedTo); + Debug.Assert(Arguments[firstArgument + i].ResultType == Method.Parameters[mappedTo].Type.GetStackType(), + $"Stack type mismatch in parameter {mappedTo} (argument {firstArgument + i}) in call to {Method.Name}()"); + } + Debug.Assert(bitSet.All(0, paramCount - 1), "Not all arguments are mapped to a parameter"); } } @@ -137,9 +161,12 @@ namespace ICSharpCode.Decompiler.IL output.Write(' '); Method.WriteTo(output); output.Write('('); + int firstIndex = (OpCode != OpCode.NewObj && !Method.IsStatic) ? -1 : 0; for (int i = 0; i < Arguments.Count; i++) { if (i > 0) output.Write(", "); + if (ArgumentToParameterMap[i] != firstIndex + i) + output.Write($"{ArgumentToParameterMap[i]}: "); Arguments[i].WriteTo(output, options); } output.Write(')'); @@ -150,7 +177,8 @@ namespace ICSharpCode.Decompiler.IL CallInstruction o = other as CallInstruction; return o != null && this.OpCode == o.OpCode && this.Method.Equals(o.Method) && this.IsTail == o.IsTail && object.Equals(this.ConstrainedTo, o.ConstrainedTo) - && Patterns.ListMatch.DoMatch(this.Arguments, o.Arguments, ref match); + && Patterns.ListMatch.DoMatch(this.Arguments, o.Arguments, ref match) + && ArgumentToParameterMap.SequenceEqual(o.ArgumentToParameterMap); } } diff --git a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs index d3b0dd8d3..1c9753620 100644 --- a/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs +++ b/ICSharpCode.Decompiler/IL/Instructions/CompoundAssignmentInstruction.cs @@ -28,7 +28,35 @@ namespace ICSharpCode.Decompiler.IL EvaluatesToNewValue } - public partial class CompoundAssignmentInstruction : ILInstruction + public abstract partial class CompoundAssignmentInstruction : ILInstruction + { + public readonly CompoundAssignmentType CompoundAssignmentType; + + public CompoundAssignmentInstruction(OpCode opCode, CompoundAssignmentType compoundAssignmentType, ILInstruction target, ILInstruction value) + : base(opCode) + { + this.CompoundAssignmentType = compoundAssignmentType; + this.Target = target; + this.Value = value; + } + + internal static bool IsValidCompoundAssignmentTarget(ILInstruction inst) + { + switch (inst.OpCode) { + // case OpCode.LdLoc: -- not valid -- does not mark the variable as written to + case OpCode.LdObj: + return true; + case OpCode.Call: + case OpCode.CallVirt: + var owner = ((CallInstruction)inst).Method.AccessorOwner as IProperty; + return owner != null && owner.CanSet; + default: + return false; + } + } + } + + public partial class NumericCompoundAssign : CompoundAssignmentInstruction, ILiftableInstruction { /// /// Gets whether the instruction checks for overflow. @@ -50,13 +78,11 @@ namespace ICSharpCode.Decompiler.IL /// The operator used by this assignment operator instruction. /// public readonly BinaryNumericOperator Operator; - - public readonly CompoundAssignmentType CompoundAssignmentType; public bool IsLifted { get; } - public CompoundAssignmentInstruction(BinaryNumericInstruction binary, ILInstruction target, ILInstruction value, IType type, CompoundAssignmentType compoundAssignmentType) - : base(OpCode.CompoundAssignmentInstruction) + public NumericCompoundAssign(BinaryNumericInstruction binary, ILInstruction target, ILInstruction value, IType type, CompoundAssignmentType compoundAssignmentType) + : base(OpCode.NumericCompoundAssign, compoundAssignmentType, target, value) { Debug.Assert(IsBinaryCompatibleWithType(binary, type)); this.CheckForOverflow = binary.CheckForOverflow; @@ -65,11 +91,8 @@ namespace ICSharpCode.Decompiler.IL this.RightInputType = binary.RightInputType; this.UnderlyingResultType = binary.UnderlyingResultType; this.Operator = binary.Operator; - this.CompoundAssignmentType = compoundAssignmentType; this.IsLifted = binary.IsLifted; - this.Target = target; this.type = type; - this.Value = value; this.ILRange = binary.ILRange; Debug.Assert(compoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue || (Operator == BinaryNumericOperator.Add || Operator == BinaryNumericOperator.Sub)); Debug.Assert(IsValidCompoundAssignmentTarget(Target)); @@ -85,7 +108,9 @@ namespace ICSharpCode.Decompiler.IL return false; type = NullableType.GetUnderlyingType(type); } - if (type.Kind == TypeKind.Enum) { + if (type.Kind == TypeKind.Unknown) { + return false; // avoid introducing a potentially-incorrect compound assignment + } else if (type.Kind == TypeKind.Enum) { switch (binary.Operator) { case BinaryNumericOperator.Add: case BinaryNumericOperator.Sub: @@ -111,30 +136,25 @@ namespace ICSharpCode.Decompiler.IL } } if (binary.Sign != Sign.None) { - if (type.GetSign() != binary.Sign) - return false; + if (type.IsCSharpSmallIntegerType()) { + // C# will use numeric promotion to int, binary op must be signed + if (binary.Sign != Sign.Signed) + return false; + } else { + // C# will use sign from type + if (type.GetSign() != binary.Sign) + return false; + } } + // Can't transform if the RHS value would be need to be truncated for the LHS type. + if (Transforms.TransformAssignment.IsImplicitTruncation(binary.Right, type, binary.IsLifted)) + return false; return true; } - internal static bool IsValidCompoundAssignmentTarget(ILInstruction inst) - { - switch (inst.OpCode) { - // case OpCode.LdLoc: -- not valid -- does not mark the variable as written to - case OpCode.LdObj: - return true; - case OpCode.Call: - case OpCode.CallVirt: - var owner = ((CallInstruction)inst).Method.AccessorOwner as IProperty; - return owner != null && owner.CanSet; - default: - return false; - } - } - protected override InstructionFlags ComputeFlags() { - var flags = target.Flags | value.Flags | InstructionFlags.SideEffect; + var flags = Target.Flags | Value.Flags | InstructionFlags.SideEffect; if (CheckForOverflow || (Operator == BinaryNumericOperator.Div || Operator == BinaryNumericOperator.Rem)) flags |= InstructionFlags.MayThrow; return flags; @@ -148,40 +168,12 @@ namespace ICSharpCode.Decompiler.IL return flags; } } - - string GetOperatorName(BinaryNumericOperator @operator) - { - switch (@operator) { - case BinaryNumericOperator.Add: - return "add"; - case BinaryNumericOperator.Sub: - return "sub"; - case BinaryNumericOperator.Mul: - return "mul"; - case BinaryNumericOperator.Div: - return "div"; - case BinaryNumericOperator.Rem: - return "rem"; - case BinaryNumericOperator.BitAnd: - return "bit.and"; - case BinaryNumericOperator.BitOr: - return "bit.or"; - case BinaryNumericOperator.BitXor: - return "bit.xor"; - case BinaryNumericOperator.ShiftLeft: - return "bit.shl"; - case BinaryNumericOperator.ShiftRight: - return "bit.shr"; - default: - throw new ArgumentOutOfRangeException(); - } - } - + public override void WriteTo(ITextOutput output, ILAstWritingOptions options) { ILRange.WriteTo(output, options); output.Write(OpCode); - output.Write("." + GetOperatorName(Operator)); + output.Write("." + BinaryNumericInstruction.GetOperatorName(Operator)); if (CompoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue) output.Write(".new"); else @@ -199,6 +191,40 @@ namespace ICSharpCode.Decompiler.IL output.Write(')'); } } + + public partial class UserDefinedCompoundAssign : CompoundAssignmentInstruction + { + public readonly IMethod Method; + public bool IsLifted => false; // TODO: implement ILi + + public UserDefinedCompoundAssign(IMethod method, CompoundAssignmentType compoundAssignmentType, ILInstruction target, ILInstruction value) + : base(OpCode.UserDefinedCompoundAssign, compoundAssignmentType, target, value) + { + this.Method = method; + Debug.Assert(Method.IsOperator); + Debug.Assert(compoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue || (Method.Name == "op_Increment" || Method.Name == "op_Decrement")); + Debug.Assert(IsValidCompoundAssignmentTarget(Target)); + } + + public override StackType ResultType => Method.ReturnType.GetStackType(); + + public override void WriteTo(ITextOutput output, ILAstWritingOptions options) + { + ILRange.WriteTo(output, options); + output.Write(OpCode); + if (CompoundAssignmentType == CompoundAssignmentType.EvaluatesToNewValue) + output.Write(".new"); + else + output.Write(".old"); + output.Write(' '); + Method.WriteTo(output); + output.Write('('); + this.Target.WriteTo(output, options); + output.Write(", "); + this.Value.WriteTo(output, options); + output.Write(')'); + } + } } diff --git a/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs b/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs index 06b9132ec..70e37a245 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs @@ -63,7 +63,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms loopCounters = CollectLoopCounters(function); foreach (var f in function.Descendants.OfType()) { if (f.Method != null) { - if (f.Method.IsAccessor && f.Method.Parameters.Count > 0) { + if (IsSetOrEventAccessor(f.Method) && f.Method.Parameters.Count > 0) { for (int i = 0; i < f.Method.Parameters.Count - 1; i++) { AddExistingName(reservedVariableNames, f.Method.Parameters[i].Name); } @@ -121,6 +121,15 @@ namespace ICSharpCode.Decompiler.IL.Transforms } } + bool IsSetOrEventAccessor(IMethod method) + { + if (method.AccessorOwner is IProperty p) + return p.Setter == method; + if (method.AccessorOwner is IEvent e) + return e.InvokeAccessor != method; + return false; + } + void PerformAssignment(ILFunction function) { // remove unused variables before assigning names diff --git a/ICSharpCode.Decompiler/IL/Transforms/DelegateConstruction.cs b/ICSharpCode.Decompiler/IL/Transforms/DelegateConstruction.cs index 3451c2ec6..3df0df8e6 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/DelegateConstruction.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/DelegateConstruction.cs @@ -321,9 +321,9 @@ namespace ICSharpCode.Decompiler.IL.Transforms } } - protected internal override void VisitCompoundAssignmentInstruction(CompoundAssignmentInstruction inst) + protected internal override void VisitNumericCompoundAssign(NumericCompoundAssign inst) { - base.VisitCompoundAssignmentInstruction(inst); + base.VisitNumericCompoundAssign(inst); if (inst.Target.MatchLdLoc(out var v)) { inst.ReplaceWith(new StLoc(v, new BinaryNumericInstruction(inst.Operator, inst.Target, inst.Value, inst.CheckForOverflow, inst.Sign))); } diff --git a/ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs b/ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs index 5160739e3..12f47812c 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/ExpressionTransforms.cs @@ -241,14 +241,14 @@ namespace ICSharpCode.Decompiler.IL.Transforms expr.AcceptVisitor(this); } else { base.VisitCall(inst); - TransformAssignment.HandleCallCompoundAssign(inst, context); + TransformAssignment.HandleCompoundAssign(inst, context); } } protected internal override void VisitCallVirt(CallVirt inst) { base.VisitCallVirt(inst); - TransformAssignment.HandleCallCompoundAssign(inst, context); + TransformAssignment.HandleCompoundAssign(inst, context); } protected internal override void VisitNewObj(NewObj inst) @@ -301,8 +301,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms context.RequestRerun(); return; } - TransformAssignment.HandleStObjCompoundAssign(inst, context); - } + TransformAssignment.HandleCompoundAssign(inst, context); + } protected internal override void VisitIfInstruction(IfInstruction inst) { diff --git a/ICSharpCode.Decompiler/IL/Transforms/HighLevelLoopTransform.cs b/ICSharpCode.Decompiler/IL/Transforms/HighLevelLoopTransform.cs index a6e2739f3..aa2ce86cf 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/HighLevelLoopTransform.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/HighLevelLoopTransform.cs @@ -451,7 +451,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms case OpCode.NewObj: case OpCode.StLoc: case OpCode.StObj: - case OpCode.CompoundAssignmentInstruction: + case OpCode.NumericCompoundAssign: + case OpCode.UserDefinedCompoundAssign: return true; default: return false; diff --git a/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs index 391c19286..6fa0e1283 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/ILInlining.cs @@ -296,7 +296,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms switch (inlinedExpression.OpCode) { case OpCode.DefaultValue: case OpCode.StObj: - case OpCode.CompoundAssignmentInstruction: + case OpCode.NumericCompoundAssign: + case OpCode.UserDefinedCompoundAssign: case OpCode.Await: return true; case OpCode.LdLoc: diff --git a/ICSharpCode.Decompiler/IL/Transforms/RemoveDeadVariableInit.cs b/ICSharpCode.Decompiler/IL/Transforms/RemoveDeadVariableInit.cs index 91ed54025..52ecb6e81 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/RemoveDeadVariableInit.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/RemoveDeadVariableInit.cs @@ -19,6 +19,7 @@ using System.Collections.Generic; using System.Linq; using ICSharpCode.Decompiler.FlowAnalysis; +using ICSharpCode.Decompiler.TypeSystem; namespace ICSharpCode.Decompiler.IL.Transforms { @@ -27,6 +28,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms /// (=the initial value is a dead store). /// /// In yield return generators, additionally removes dead 'V = null;' assignments. + /// + /// Additionally infers IType of stack slots that have StackType.Ref /// public class RemoveDeadVariableInit : IILTransform { @@ -66,6 +69,26 @@ namespace ICSharpCode.Decompiler.IL.Transforms } } } + + // Try to infer IType of stack slots that are of StackType.Ref: + foreach (var v in function.Variables) { + if (v.Kind == VariableKind.StackSlot && v.StackType == StackType.Ref && v.AddressCount == 0) { + IType newType = null; + // Multiple store are possible in case of (c ? ref a : ref b) += 1, for example. + foreach (var stloc in v.StoreInstructions.OfType()) { + var inferredType = stloc.Value.InferType(); + // cancel, if types of values do not match exactly + if (newType != null && !newType.Equals(inferredType)) { + newType = SpecialType.UnknownType; + break; + } + newType = inferredType; + } + // Only overwrite existing type, if a "better" type was found. + if (newType != null && newType != SpecialType.UnknownType) + v.Type = newType; + } + } } } } diff --git a/ICSharpCode.Decompiler/IL/Transforms/SwitchOnStringTransform.cs b/ICSharpCode.Decompiler/IL/Transforms/SwitchOnStringTransform.cs index 7668accde..5c57f4264 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/SwitchOnStringTransform.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/SwitchOnStringTransform.cs @@ -25,6 +25,8 @@ using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.IL.Transforms { + using HashtableInitializer = Dictionary Labels, IfInstruction JumpToNext, Block ContainingBlock, Block Previous, Block Next, bool Transformed)>; + /// /// Detects switch-on-string patterns employed by the C# compiler and transforms them to an ILAst-switch-instruction. /// @@ -35,6 +37,9 @@ namespace ICSharpCode.Decompiler.IL.Transforms if (!context.Settings.SwitchStatementOnString) return; + BlockContainer body = (BlockContainer)function.Body; + var hashtableInitializers = ScanHashtableInitializerBlocks(body.EntryPoint); + HashSet changedContainers = new HashSet(); foreach (var block in function.Descendants.OfType()) { @@ -44,7 +49,11 @@ namespace ICSharpCode.Decompiler.IL.Transforms changed = true; continue; } - if (MatchLegacySwitchOnStringWithHashtable(block.Instructions, ref i)) { + if (SimplifyCSharp1CascadingIfStatements(block.Instructions, ref i)) { + changed = true; + continue; + } + if (MatchLegacySwitchOnStringWithHashtable(block, hashtableInitializers, ref i)) { changed = true; continue; } @@ -63,10 +72,83 @@ namespace ICSharpCode.Decompiler.IL.Transforms changedContainers.Add(container); } + var omittedBlocks = new Dictionary(); + + // Remove all transformed hashtable initializers from the entrypoint. + foreach (var item in hashtableInitializers) { + var (labels, jumpToNext, containingBlock, previous, next, transformed) = item.Value; + if (!transformed) continue; + if (!omittedBlocks.TryGetValue(previous, out var actual)) + actual = previous; + if (jumpToNext != null) { + actual.Instructions.SecondToLastOrDefault().ReplaceWith(jumpToNext); + } + actual.Instructions.LastOrDefault().ReplaceWith(new Branch(next)); + omittedBlocks.Add(containingBlock, previous); + changedContainers.Add(body); + } + + // If all initializer where removed, remove the initial null check as well. + if (hashtableInitializers.Count > 0 && omittedBlocks.Count == hashtableInitializers.Count && body.EntryPoint.Instructions.Count == 2) { + if (body.EntryPoint.Instructions[0] is IfInstruction ifInst + && ifInst.TrueInst.MatchBranch(out var beginOfMethod) && body.EntryPoint.Instructions[1].MatchBranch(beginOfMethod)) { + body.EntryPoint.Instructions.RemoveAt(0); + } + } + foreach (var container in changedContainers) container.SortBlocks(deleteUnreachableBlocks: true); } + HashtableInitializer ScanHashtableInitializerBlocks(Block entryPoint) + { + var hashtables = new HashtableInitializer(); + if (entryPoint.Instructions.Count != 2) + return hashtables; + // match first block: checking compiler-generated Hashtable for null + // if (comp(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f-1) != ldnull)) br switchHeadBlock + // br tableInitBlock + if (!(entryPoint.Instructions[0].MatchIfInstruction(out var condition, out var branchToSwitchHead))) + return hashtables; + if (!entryPoint.Instructions[1].MatchBranch(out var tableInitBlock)) + return hashtables; + if (!(condition.MatchCompNotEquals(out var left, out var right) && right.MatchLdNull() && + MatchDictionaryFieldLoad(left, IsNonGenericHashtable, out var dictField, out var dictionaryType))) + return hashtables; + if (!branchToSwitchHead.MatchBranch(out var switchHead)) + return hashtables; + // match second block: initialization of compiler-generated Hashtable + // stloc table(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f loadFactor)) + // call Add(ldloc table, ldstr value, box System.Int32(ldc.i4 index)) + // ... more calls to Add ... + // volatile.stobj System.Collections.Hashtable(ldsflda $$method0x600003f - 1, ldloc table) + // br switchHeadBlock + if (tableInitBlock.IncomingEdgeCount != 1 || tableInitBlock.Instructions.Count < 3) + return hashtables; + Block previousBlock = entryPoint; + while (tableInitBlock != null) { + if (!ExtractStringValuesFromInitBlock(tableInitBlock, out var stringValues, out var blockAfterThisInitBlock, dictionaryType, dictField, true)) + break; + var nextHashtableInitHead = tableInitBlock.Instructions.SecondToLastOrDefault() as IfInstruction; + hashtables.Add(dictField, (stringValues, nextHashtableInitHead, tableInitBlock, previousBlock, blockAfterThisInitBlock, false)); + previousBlock = tableInitBlock; + // if there is another IfInstruction before the end of the block, it might be a jump to the next hashtable init block. + // if (comp(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f-2) != ldnull)) br switchHeadBlock + if (nextHashtableInitHead != null) { + if (!(nextHashtableInitHead.Condition.MatchCompNotEquals(out left, out right) && right.MatchLdNull() && + MatchDictionaryFieldLoad(left, IsNonGenericHashtable, out var nextDictField, out _))) + break; + if (!nextHashtableInitHead.TrueInst.MatchBranch(switchHead)) + break; + tableInitBlock = blockAfterThisInitBlock; + dictField = nextDictField; + } else { + break; + } + } + return hashtables; + } + bool SimplifyCascadingIfStatements(InstructionCollection instructions, ref int i) { if (i < 1) return false; @@ -98,8 +180,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms var otherSwitchValueVar = switchValueVar; switchValueVar = stloc.Variable; if (i >= 2 && instructions[i - 2].MatchStLoc(otherSwitchValueVar, out switchValue) - && otherSwitchValueVar.IsSingleDefinition && otherSwitchValueVar.LoadCount == 2) - { + && otherSwitchValueVar.IsSingleDefinition && otherSwitchValueVar.LoadCount == 2) { extraLoad = true; } else { switchValue = new LdLoc(otherSwitchValueVar); @@ -148,6 +229,91 @@ namespace ICSharpCode.Decompiler.IL.Transforms return true; } + bool SimplifyCSharp1CascadingIfStatements(InstructionCollection instructions, ref int i) + { + if (i < 1) return false; + // match first block: + // stloc switchValueVar(ldloc temp) + // if (comp(ldloc temp == ldnull)) br defaultBlock + // br isInternedBlock + if (!(instructions[i].MatchIfInstruction(out var condition, out var defaultBlockJump))) + return false; + if (!instructions[i + 1].MatchBranch(out var isInternedBlock)) + return false; + if (!defaultBlockJump.MatchBranch(out var defaultOrNullBlock)) + return false; + if (!(condition.MatchCompEqualsNull(out var tempLoad) && tempLoad.MatchLdLoc(out var temp))) + return false; + if (!(temp.Kind == VariableKind.StackSlot && temp.LoadCount == 2)) + return false; + if (!(instructions[i - 1].MatchStLoc(out var switchValueVar, out var switchValue) && switchValue.MatchLdLoc(temp))) + return false; + // match isInternedBlock: + // stloc switchValueVarCopy(call IsInterned(ldloc switchValueVar)) + // if (comp(ldloc switchValueVarCopy == ldstr "case1")) br caseBlock1 + // br caseHeader2 + if (isInternedBlock.IncomingEdgeCount != 1 || isInternedBlock.Instructions.Count != 3) + return false; + if (!(isInternedBlock.Instructions[0].MatchStLoc(out var switchValueVarCopy, out var arg) && IsIsInternedCall(arg as Call, out arg) && arg.MatchLdLoc(switchValueVar))) + return false; + switchValueVar = switchValueVarCopy; + int conditionOffset = 1; + Block currentCaseBlock = isInternedBlock; + List<(string, Block)> values = new List<(string, Block)>(); + + // each case starts with: + // if (comp(ldloc switchValueVar == ldstr "case label")) br caseBlock + // br currentCaseBlock + + while (currentCaseBlock.Instructions[conditionOffset].MatchIfInstruction(out condition, out var caseBlockJump)) { + if (currentCaseBlock.Instructions.Count != conditionOffset + 2) + break; + if (!condition.MatchCompEquals(out var left, out var right)) + break; + if (!left.MatchLdLoc(switchValueVar)) + break; + if (!right.MatchLdStr(out string value)) + break; + if (!caseBlockJump.MatchBranch(out var caseBlock)) + break; + if (!currentCaseBlock.Instructions[conditionOffset + 1].MatchBranch(out currentCaseBlock)) + break; + conditionOffset = 0; + values.Add((value, caseBlock)); + } + + // switch contains case null: + if (currentCaseBlock != defaultOrNullBlock) { + values.Add((null, defaultOrNullBlock)); + } + + var sections = new List(values.SelectWithIndex((index, b) => new SwitchSection { Labels = new LongSet(index), Body = new Branch(b.Item2) })); + sections.Add(new SwitchSection { Labels = new LongSet(new LongInterval(0, sections.Count)).Invert(), Body = new Branch(currentCaseBlock) }); + var stringToInt = new StringToInt(switchValue, values.SelectArray(item => item.Item1)); + var inst = new SwitchInstruction(stringToInt); + inst.Sections.AddRange(sections); + + instructions[i].ReplaceWith(inst); + instructions.RemoveAt(i + 1); + instructions.RemoveAt(i - 1); + + return true; + } + + bool IsIsInternedCall(Call call, out ILInstruction argument) + { + if (call != null + && call.Method.DeclaringType.IsKnownType(KnownTypeCode.String) + && call.Method.IsStatic + && call.Method.Name == "IsInterned" + && call.Arguments.Count == 1) { + argument = call.Arguments[0]; + return true; + } + argument = null; + return false; + } + /// /// Each case consists of two blocks: /// 1. block: @@ -235,7 +401,9 @@ namespace ICSharpCode.Decompiler.IL.Transforms // br switchHeadBlock if (dictInitBlock.IncomingEdgeCount != 1 || dictInitBlock.Instructions.Count < 3) return false; - if (!ExtractStringValuesFromInitBlock(dictInitBlock, out var stringValues, tryGetValueBlock, dictionaryType, dictField)) + if (!ExtractStringValuesFromInitBlock(dictInitBlock, out var stringValues, out var blockAfterInit, dictionaryType, dictField, false)) + return false; + if (tryGetValueBlock != blockAfterInit) return false; // match fourth block: TryGetValue on compiler-generated Dictionary // if (logic.not(call TryGetValue(volatile.ldobj System.Collections.Generic.Dictionary`2[[System.String],[System.Int32]](ldsflda $$method0x600000c-1), ldloc switchValueVar, ldloca switchIndexVar))) br defaultBlock @@ -382,9 +550,10 @@ namespace ICSharpCode.Decompiler.IL.Transforms /// /// Matches and extracts values from Add-call sequences. /// - bool ExtractStringValuesFromInitBlock(Block block, out List<(string, int)> values, Block targetBlock, IType dictionaryType, IField dictionaryField) + bool ExtractStringValuesFromInitBlock(Block block, out List<(string, int)> values, out Block blockAfterInit, IType dictionaryType, IField dictionaryField, bool isHashtablePattern) { values = null; + blockAfterInit = null; // stloc dictVar(newobj Dictionary..ctor(ldc.i4 valuesLength)) // -or- // stloc dictVar(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f4 loadFactor)) @@ -414,7 +583,10 @@ namespace ICSharpCode.Decompiler.IL.Transforms dictType.Equals(dictionaryType) && loadField.MatchLdsFlda(out var dictField) && dictField.Equals(dictionaryField) && dictVarLoad.MatchLdLoc(dictVar))) return false; - return block.Instructions[i + 2].MatchBranch(targetBlock); + if (isHashtablePattern && block.Instructions[i + 2] is IfInstruction) { + return block.Instructions[i + 3].MatchBranch(out blockAfterInit); + } + return block.Instructions[i + 2].MatchBranch(out blockAfterInit); } /// @@ -454,48 +626,26 @@ namespace ICSharpCode.Decompiler.IL.Transforms return true; } - bool MatchLegacySwitchOnStringWithHashtable(InstructionCollection instructions, ref int i) + bool MatchLegacySwitchOnStringWithHashtable(Block block, HashtableInitializer hashtableInitializers, ref int i) { - // match first block: checking compiler-generated Hashtable for null - // if (comp(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f-1) != ldnull)) br switchHeadBlock - // br tableInitBlock - if (!(instructions[i].MatchIfInstruction(out var condition, out var branchToSwitchHead) && i + 1 < instructions.Count)) - return false; - if (!instructions[i + 1].MatchBranch(out var tableInitBlock) || tableInitBlock.IncomingEdgeCount != 1) - return false; - if (!(condition.MatchCompNotEquals(out var left, out var right) && right.MatchLdNull() && - MatchDictionaryFieldLoad(left, IsNonGenericHashtable, out var dictField, out var dictionaryType))) - return false; - if (!branchToSwitchHead.MatchBranch(out var switchHead)) - return false; - // match second block: initialization of compiler-generated Hashtable - // stloc table(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f loadFactor)) - // call Add(ldloc table, ldstr value, box System.Int32(ldc.i4 index)) - // ... more calls to Add ... - // volatile.stobj System.Collections.Hashtable(ldsflda $$method0x600003f - 1, ldloc table) - // br switchHeadBlock - if (tableInitBlock.IncomingEdgeCount != 1 || tableInitBlock.Instructions.Count < 3) - return false; - if (!ExtractStringValuesFromInitBlock(tableInitBlock, out var stringValues, switchHead, dictionaryType, dictField)) - return false; - // match third block: checking switch-value for null + // match first block: checking switch-value for null // stloc tmp(ldloc switch-value) // stloc switchVariable(ldloc tmp) // if (comp(ldloc tmp == ldnull)) br nullCaseBlock - // br getItemBlock - if (switchHead.Instructions.Count != 4 || switchHead.IncomingEdgeCount != 2) + // br getItemBloc + if (block.Instructions.Count != i + 4) return false; - if (!switchHead.Instructions[0].MatchStLoc(out var tmp, out var switchValue)) + if (!block.Instructions[i].MatchStLoc(out var tmp, out var switchValue)) return false; - if (!switchHead.Instructions[1].MatchStLoc(out var switchVariable, out var tmpLoad) || !tmpLoad.MatchLdLoc(tmp)) + if (!block.Instructions[i + 1].MatchStLoc(out var switchVariable, out var tmpLoad) || !tmpLoad.MatchLdLoc(tmp)) return false; - if (!switchHead.Instructions[2].MatchIfInstruction(out condition, out var nullCaseBlockBranch)) + if (!block.Instructions[i + 2].MatchIfInstruction(out var condition, out var nullCaseBlockBranch)) return false; - if (!switchHead.Instructions[3].MatchBranch(out var getItemBlock) || !nullCaseBlockBranch.MatchBranch(out var nullCaseBlock)) + if (!block.Instructions[i + 3].MatchBranch(out var getItemBlock) || !(nullCaseBlockBranch.MatchBranch(out var nullCaseBlock) || nullCaseBlockBranch is Leave)) return false; - if (!(condition.MatchCompEquals(out left, out right) && right.MatchLdNull() && left.MatchLdLoc(tmp))) + if (!(condition.MatchCompEquals(out var left, out var right) && right.MatchLdNull() && left.MatchLdLoc(tmp))) return false; - // match fourth block: get_Item on compiler-generated Hashtable + // match second block: get_Item on compiler-generated Hashtable // stloc tmp2(call get_Item(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f - 1), ldloc switchVariable)) // stloc switchVariable(ldloc tmp2) // if (comp(ldloc tmp2 == ldnull)) br defaultCaseBlock @@ -510,14 +660,17 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; if (!getItemBlock.Instructions[2].MatchIfInstruction(out condition, out var defaultBlockBranch)) return false; - if (!getItemBlock.Instructions[3].MatchBranch(out var switchBlock) || !defaultBlockBranch.MatchBranch(out var defaultBlock)) + if (!getItemBlock.Instructions[3].MatchBranch(out var switchBlock) || !(defaultBlockBranch.MatchBranch(out var defaultBlock) || defaultBlockBranch is Leave)) return false; if (!(condition.MatchCompEquals(out left, out right) && right.MatchLdNull() && left.MatchLdLoc(tmp2))) return false; - if (!(getItemCall.Arguments.Count == 2 && MatchDictionaryFieldLoad(getItemCall.Arguments[0], IsStringToIntDictionary, out var dictField2, out _) && dictField2.Equals(dictField)) && - getItemCall.Arguments[1].MatchLdLoc(switchVariable2)) + if (!(getItemCall.Arguments.Count == 2 && MatchDictionaryFieldLoad(getItemCall.Arguments[0], IsNonGenericHashtable, out var dictField, out _) && getItemCall.Arguments[1].MatchLdLoc(switchVariable))) return false; - // match fifth block: switch-instruction block + // Check if there is a hashtable init block at the beginning of the method + if (!hashtableInitializers.TryGetValue(dictField, out var info)) + return false; + var stringValues = info.Labels; + // match third block: switch-instruction block // switch (ldobj System.Int32(unbox System.Int32(ldloc switchVariable))) { // case [0..1): br caseBlock1 // ... more cases ... @@ -530,7 +683,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; var sections = new List(switchInst.Sections); // switch contains case null: - if (nullCaseBlock != defaultBlock) { + if (!(nullCaseBlockBranch is Leave) && nullCaseBlock != defaultBlock) { if (!AddNullSection(sections, stringValues, nullCaseBlock)) { return false; } @@ -538,8 +691,55 @@ namespace ICSharpCode.Decompiler.IL.Transforms var stringToInt = new StringToInt(switchValue, stringValues); var inst = new SwitchInstruction(stringToInt); inst.Sections.AddRange(sections); - instructions[i + 1].ReplaceWith(inst); - instructions.RemoveAt(i); + block.Instructions[i].ReplaceWith(inst); + block.Instructions.RemoveRange(i + 1, 3); + info.Transformed = true; + hashtableInitializers[dictField] = info; + return true; + } + + bool FindHashtableInitBlock(Block entryPoint, out List<(string, int)> stringValues, out IField dictField, out Block blockAfterThisInitBlock, out ILInstruction thisSwitchInitJumpInst, out ILInstruction nextSwitchInitJumpInst) + { + stringValues = null; + dictField = null; + blockAfterThisInitBlock = null; + nextSwitchInitJumpInst = null; + thisSwitchInitJumpInst = null; + if (entryPoint.Instructions.Count != 2) + return false; + // match first block: checking compiler-generated Hashtable for null + // if (comp(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f-1) != ldnull)) br switchHeadBlock + // br tableInitBlock + if (!(entryPoint.Instructions[0].MatchIfInstruction(out var condition, out var branchToSwitchHead))) + return false; + if (!entryPoint.Instructions[1].MatchBranch(out var tableInitBlock)) + return false; + if (!(condition.MatchCompNotEquals(out var left, out var right) && right.MatchLdNull() && + MatchDictionaryFieldLoad(left, IsNonGenericHashtable, out dictField, out var dictionaryType))) + return false; + if (!branchToSwitchHead.MatchBranch(out var switchHead)) + return false; + thisSwitchInitJumpInst = entryPoint.Instructions[0]; + // match second block: initialization of compiler-generated Hashtable + // stloc table(newobj Hashtable..ctor(ldc.i4 capacity, ldc.f loadFactor)) + // call Add(ldloc table, ldstr value, box System.Int32(ldc.i4 index)) + // ... more calls to Add ... + // volatile.stobj System.Collections.Hashtable(ldsflda $$method0x600003f - 1, ldloc table) + // br switchHeadBlock + if (tableInitBlock.IncomingEdgeCount != 1 || tableInitBlock.Instructions.Count < 3) + return false; + if (!ExtractStringValuesFromInitBlock(tableInitBlock, out stringValues, out blockAfterThisInitBlock, dictionaryType, dictField, true)) + return false; + // if there is another IfInstruction before the end of the block, it might be a jump to the next hashtable init block. + // if (comp(volatile.ldobj System.Collections.Hashtable(ldsflda $$method0x600003f-2) != ldnull)) br switchHeadBlock + if (tableInitBlock.Instructions.SecondToLastOrDefault() is IfInstruction nextHashtableInitHead) { + if (!(nextHashtableInitHead.Condition.MatchCompNotEquals(out left, out right) && right.MatchLdNull() && + MatchDictionaryFieldLoad(left, IsNonGenericHashtable, out var nextSwitchInitField, out _))) + return false; + if (!nextHashtableInitHead.TrueInst.MatchBranch(switchHead)) + return false; + nextSwitchInitJumpInst = nextHashtableInitHead; + } return true; } @@ -598,7 +798,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms } /// - /// Matches and the negated version: + /// Matches (and the negated version): /// if (call op_Equality(ldloc V_0, ldstr "Fifth case")) br body /// br exit /// @@ -610,15 +810,15 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; if (!target.Instructions[0].MatchIfInstruction(out var condition, out var bodyBranch)) return false; - if (!bodyBranch.MatchBranch(out body)) - return false; if (MatchStringEqualityComparison(condition, switchValueVar, out stringValue)) { - return body != null; + var exitBranch = target.Instructions[1]; + if (!(exitBranch.MatchBranch(out _) || exitBranch.MatchLeave(out _))) + return false; + return bodyBranch.MatchBranch(out body) && body != null; } else if (condition.MatchLogicNot(out condition) && MatchStringEqualityComparison(condition, switchValueVar, out stringValue)) { - if (!target.Instructions[1].MatchBranch(out Block exit)) + if (!(bodyBranch.MatchBranch(out _) || bodyBranch.MatchLeave(out _))) return false; - body = exit; - return true; + return target.Instructions[1].MatchBranch(out body) && body != null; } else { return false; } diff --git a/ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs b/ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs index 2c2983685..2386a8658 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/TransformArrayInitializers.cs @@ -170,18 +170,25 @@ namespace ICSharpCode.Decompiler.IL.Transforms instructionsToRemove = 0; values = null; values = new ILInstruction[length]; - int index = 0; + int nextMinimumIndex = 0; int elementCount = 0; for (int i = pos; i < block.Instructions.Count; i++) { - if (index >= length) + if (nextMinimumIndex >= length) break; if (!block.Instructions[i].MatchStObj(out ILInstruction target, out ILInstruction value, out IType type) || value.Descendants.OfType().Any(inst => inst.Variable == store)) break; var ldelem = target as LdElema; - if (ldelem == null || !ldelem.Array.MatchLdLoc(store) || ldelem.Indices.Count != 1 || !ldelem.Indices[0].MatchLdcI4(out index)) + if (ldelem == null || !ldelem.Array.MatchLdLoc(store) || ldelem.Indices.Count != 1 || !ldelem.Indices[0].MatchLdcI4(out int index)) break; - values[index] = value; - index++; + // index must be in range [0..length[ and must be greater than or equal to nextMinimumIndex + // to avoid running out of bounds or accidentally reordering instructions or overwriting previous instructions. + // However, leaving array slots empty is allowed, as those are filled with default values when the + // initializer block is generated. + if (index < 0 || index >= length || index < nextMinimumIndex) + return false; + nextMinimumIndex = index; + values[nextMinimumIndex] = value; + nextMinimumIndex++; elementCount++; instructionsToRemove++; } @@ -283,24 +290,6 @@ namespace ICSharpCode.Decompiler.IL.Transforms return block; } - static bool CompareTypes(IType a, IType b) - { - IType type1 = DummyTypeParameter.NormalizeAllTypeParameters(a); - IType type2 = DummyTypeParameter.NormalizeAllTypeParameters(b); - return type1.Equals(type2); - } - - static bool CompareSignatures(IList parameters, IList otherParameters) - { - if (otherParameters.Count != parameters.Count) - return false; - for (int i = 0; i < otherParameters.Count; i++) { - if (!CompareTypes(otherParameters[i].Type, parameters[i].Type)) - return false; - } - return true; - } - internal static bool MatchNewArr(ILInstruction instruction, out IType arrayType, out int[] length) { NewArr newArr = instruction as NewArr; diff --git a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs index 17c2335c8..25a398df8 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/TransformAssignment.cs @@ -31,7 +31,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms public class TransformAssignment : IStatementTransform { StatementTransformContext context; - + void IStatementTransform.Run(Block block, int pos, StatementTransformContext context) { this.context = context; @@ -112,10 +112,18 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; if (!SemanticHelper.IsPure(stobj.Target.Flags) || inst.Variable.IsUsedWithin(stobj.Target)) return false; - if (IsImplicitTruncation(inst.Value, stobj.Type)) { + var newType = stobj.Target.InferType(); + if (newType is ByReferenceType byref) + newType = byref.ElementType; + else if (newType is PointerType pointer) + newType = pointer.ElementType; + else + newType = stobj.Type; + if (IsImplicitTruncation(inst.Value, newType)) { // 'stobj' is implicitly truncating the value return false; } + stobj.Type = newType; context.Step("Inline assignment stobj", stobj); block.Instructions.Remove(localStore); block.Instructions.Remove(stobj); @@ -153,7 +161,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms }; inst.ReplaceWith(new StLoc(local, inlineBlock)); // because the ExpressionTransforms don't look into inline blocks, manually trigger HandleCallCompoundAssign - if (HandleCallCompoundAssign(call, context)) { + if (HandleCompoundAssign(call, context)) { // if we did construct a compound assignment, it should have made our inline block redundant: if (inlineBlock.Instructions.Single().MatchStLoc(newVar, out var compoundAssign)) { Debug.Assert(newVar.IsSingleDefinition && newVar.LoadCount == 1); @@ -165,7 +173,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; } } - + static ILInstruction UnwrapSmallIntegerConv(ILInstruction inst, out Conv conv) { conv = inst as Conv; @@ -179,17 +187,19 @@ namespace ICSharpCode.Decompiler.IL.Transforms static bool ValidateCompoundAssign(BinaryNumericInstruction binary, Conv conv, IType targetType) { - if (!CompoundAssignmentInstruction.IsBinaryCompatibleWithType(binary, targetType)) + if (!NumericCompoundAssign.IsBinaryCompatibleWithType(binary, targetType)) return false; if (conv != null && !(conv.TargetType == targetType.ToPrimitiveType() && conv.CheckForOverflow == binary.CheckForOverflow)) return false; // conv does not match binary operation return true; } - + static bool MatchingGetterAndSetterCalls(CallInstruction getterCall, CallInstruction setterCall) { if (getterCall == null || setterCall == null || !IsSameMember(getterCall.Method.AccessorOwner, setterCall.Method.AccessorOwner)) return false; + if (setterCall.OpCode != getterCall.OpCode) + return false; var owner = getterCall.Method.AccessorOwner as IProperty; if (owner == null || !IsSameMember(getterCall.Method, owner.Getter) || !IsSameMember(setterCall.Method, owner.Setter)) return false; @@ -208,89 +218,93 @@ namespace ICSharpCode.Decompiler.IL.Transforms /// /// Transform compound assignments where the return value is not being used, /// or where there's an inlined assignment within the setter call. + /// + /// Patterns handled: + /// 1. + /// callvirt set_Property(ldloc S_1, binary.op(callvirt get_Property(ldloc S_1), value)) + /// ==> compound.op.new(callvirt get_Property(ldloc S_1), value) + /// 2. + /// callvirt set_Property(ldloc S_1, stloc v(binary.op(callvirt get_Property(ldloc S_1), value))) + /// ==> stloc v(compound.op.new(callvirt get_Property(ldloc S_1), value)) + /// 3. + /// stobj(target, binary.op(ldobj(target), ...)) + /// where target is pure + /// => compound.op(target, ...) /// /// - /// Called by ExpressionTransforms. + /// Called by ExpressionTransforms, or after the inline-assignment transform for setters. /// - internal static bool HandleCallCompoundAssign(CallInstruction setterCall, StatementTransformContext context) + internal static bool HandleCompoundAssign(ILInstruction compoundStore, StatementTransformContext context) { - // callvirt set_Property(ldloc S_1, binary.op(callvirt get_Property(ldloc S_1), value)) - // ==> compound.op.new(callvirt get_Property(ldloc S_1), value) - var setterValue = setterCall.Arguments.LastOrDefault(); + if (compoundStore is CallInstruction && compoundStore.SlotInfo != Block.InstructionSlot) { + // replacing 'call set_Property' with a compound assignment instruction + // changes the return value of the expression, so this is only valid on block-level. + return false; + } + if (!IsCompoundStore(compoundStore, out var targetType, out var setterValue)) + return false; + // targetType = The type of the property/field/etc. being stored to. + // setterValue = The value being stored. var storeInSetter = setterValue as StLoc; if (storeInSetter != null) { + // We'll move the stloc to top-level: // callvirt set_Property(ldloc S_1, stloc v(binary.op(callvirt get_Property(ldloc S_1), value))) // ==> stloc v(compound.op.new(callvirt get_Property(ldloc S_1), value)) setterValue = storeInSetter.Value; + if (storeInSetter.Variable.Type.IsSmallIntegerType()) { + // 'stloc v' implicitly truncates the value. + // Ensure that type of 'v' matches the type of the property: + if (storeInSetter.Variable.Type.GetSize() != targetType.GetSize()) + return false; + if (storeInSetter.Variable.Type.GetSign() != targetType.GetSign()) + return false; + } } - setterValue = UnwrapSmallIntegerConv(setterValue, out var conv); - if (!(setterValue is BinaryNumericInstruction binary)) - return false; - var getterCall = binary.Left as CallInstruction; - if (!MatchingGetterAndSetterCalls(getterCall, setterCall)) - return false; - IType targetType = getterCall.Method.ReturnType; - if (!ValidateCompoundAssign(binary, conv, targetType)) - return false; - if (storeInSetter != null && storeInSetter.Variable.Type.IsSmallIntegerType()) { - // 'stloc v' implicitly truncates. - // Ensure that type of 'v' must match type of the property: - if (storeInSetter.Variable.Type.GetSize() != targetType.GetSize()) + ILInstruction newInst; + if (UnwrapSmallIntegerConv(setterValue, out var smallIntConv) is BinaryNumericInstruction binary) { + if (!IsMatchingCompoundLoad(binary.Left, compoundStore, forbiddenVariable: storeInSetter?.Variable)) + return false; + if (!ValidateCompoundAssign(binary, smallIntConv, targetType)) return false; - if (storeInSetter.Variable.Type.GetSign() != targetType.GetSign()) + context.Step($"Compound assignment (binary.numeric)", compoundStore); + newInst = new NumericCompoundAssign( + binary, binary.Left, binary.Right, + targetType, CompoundAssignmentType.EvaluatesToNewValue); + } else if (setterValue is Call operatorCall && operatorCall.Method.IsOperator) { + if (operatorCall.Arguments.Count == 0) return false; + if (!IsMatchingCompoundLoad(operatorCall.Arguments[0], compoundStore, forbiddenVariable: storeInSetter?.Variable)) + return false; + ILInstruction rhs; + if (operatorCall.Arguments.Count == 2) { + if (CSharp.ExpressionBuilder.GetAssignmentOperatorTypeFromMetadataName(operatorCall.Method.Name) == null) + return false; + rhs = operatorCall.Arguments[1]; + } else if (operatorCall.Arguments.Count == 1) { + if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement")) + return false; + // use a dummy node so that we don't need a dedicated instruction for user-defined unary operator calls + rhs = new LdcI4(1); + } else { + return false; + } + if (operatorCall.IsLifted) + return false; // TODO: add tests and think about whether nullables need special considerations + context.Step($"Compound assignment (user-defined binary)", compoundStore); + newInst = new UserDefinedCompoundAssign(operatorCall.Method, CompoundAssignmentType.EvaluatesToNewValue, + operatorCall.Arguments[0], rhs); + } else { + return false; } - context.Step($"Compound assignment to '{getterCall.Method.AccessorOwner.Name}'", setterCall); - ILInstruction newInst = new CompoundAssignmentInstruction( - binary, getterCall, binary.Right, - getterCall.Method.ReturnType, CompoundAssignmentType.EvaluatesToNewValue); if (storeInSetter != null) { storeInSetter.Value = newInst; newInst = storeInSetter; context.RequestRerun(); // moving stloc to top-level might trigger inlining } - setterCall.ReplaceWith(newInst); - return true; - } - - /// - /// stobj(target, binary.op(ldobj(target), ...)) - /// where target is pure - /// => compound.op(target, ...) - /// - /// - /// Called by ExpressionTransforms. - /// - internal static bool HandleStObjCompoundAssign(StObj inst, ILTransformContext context) - { - if (!(UnwrapSmallIntegerConv(inst.Value, out var conv) is BinaryNumericInstruction binary)) - return false; - if (!(binary.Left is LdObj ldobj)) - return false; - if (!inst.Target.Match(ldobj.Target).Success) - return false; - if (!SemanticHelper.IsPure(ldobj.Target.Flags)) - return false; - // ldobj.Type may just be 'int' (due to ldind.i4) when we're actually operating on a 'ref MyEnum'. - // Try to determine the real type of the object we're modifying: - IType targetType = ldobj.Target.InferType(); - if (targetType.Kind == TypeKind.Pointer || targetType.Kind == TypeKind.ByReference) { - targetType = ((TypeWithElementType)targetType).ElementType; - if (targetType.Kind == TypeKind.Unknown || targetType.GetSize() != ldobj.Type.GetSize()) { - targetType = ldobj.Type; - } - } else { - targetType = ldobj.Type; - } - if (!ValidateCompoundAssign(binary, conv, targetType)) - return false; - context.Step("compound assignment", inst); - inst.ReplaceWith(new CompoundAssignmentInstruction( - binary, binary.Left, binary.Right, - targetType, CompoundAssignmentType.EvaluatesToNewValue)); + compoundStore.ReplaceWith(newInst); return true; } - + /// /// stloc s(value) /// stloc l(ldloc s) @@ -332,7 +346,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms /// Gets whether 'stobj type(..., value)' would evaluate to a different value than 'value' /// due to implicit truncation. /// - bool IsImplicitTruncation(ILInstruction value, IType type) + static internal bool IsImplicitTruncation(ILInstruction value, IType type, bool allowNullableValue = false) { if (!type.IsSmallIntegerType()) { // Implicit truncation in ILAst only happens for small integer types; @@ -361,15 +375,21 @@ namespace ICSharpCode.Decompiler.IL.Transforms return conv.TargetType != type.ToPrimitiveType(); } else if (value is Comp) { return false; // comp returns 0 or 1, which always fits + } else if (value is IfInstruction ifInst) { + return IsImplicitTruncation(ifInst.TrueInst, type, allowNullableValue) + || IsImplicitTruncation(ifInst.FalseInst, type, allowNullableValue); } else { IType inferredType = value.InferType(); + if (allowNullableValue) { + inferredType = NullableType.GetUnderlyingType(inferredType); + } if (inferredType.Kind != TypeKind.Unknown) { return !(inferredType.GetSize() <= type.GetSize() && inferredType.GetSign() == type.GetSign()); } } return true; } - + /// /// stloc s(ldloc l) /// stloc l(binary.op(ldloc s, ldc.i4 1)) @@ -407,16 +427,25 @@ namespace ICSharpCode.Decompiler.IL.Transforms block.Instructions.RemoveAt(pos + 1); // remove nextInst return true; } - + /// /// Gets whether 'inst' is a possible store for use as a compound store. /// - bool IsCompoundStore(ILInstruction inst, out IType storeType, out ILInstruction value) + static bool IsCompoundStore(ILInstruction inst, out IType storeType, out ILInstruction value) { value = null; storeType = null; if (inst is StObj stobj) { - storeType = stobj.Type; + // stobj.Type may just be 'int' (due to stind.i4) when we're actually operating on a 'ref MyEnum'. + // Try to determine the real type of the object we're modifying: + storeType = stobj.Target.InferType(); + if (storeType is ByReferenceType refType) { + storeType = refType.ElementType; + } else if (storeType is PointerType pointerType) { + storeType = pointerType.ElementType; + } else { + storeType = stobj.Type; + } value = stobj.Value; return SemanticHelper.IsPure(stobj.Target.Flags); } else if (inst is CallInstruction call && (call.OpCode == OpCode.Call || call.OpCode == OpCode.CallVirt)) { @@ -436,17 +465,17 @@ namespace ICSharpCode.Decompiler.IL.Transforms } } - bool IsMatchingCompoundLoad(ILInstruction load, ILInstruction store, ILVariable forbiddenVariable) + static bool IsMatchingCompoundLoad(ILInstruction load, ILInstruction store, ILVariable forbiddenVariable) { if (load is LdObj ldobj && store is StObj stobj) { Debug.Assert(SemanticHelper.IsPure(stobj.Target.Flags)); if (!SemanticHelper.IsPure(ldobj.Target.Flags)) return false; - if (forbiddenVariable.IsUsedWithin(ldobj.Target)) + if (forbiddenVariable != null && forbiddenVariable.IsUsedWithin(ldobj.Target)) return false; return ldobj.Target.Match(stobj.Target).Success; } else if (MatchingGetterAndSetterCalls(load as CallInstruction, store as CallInstruction)) { - if (forbiddenVariable.IsUsedWithin(load)) + if (forbiddenVariable != null && forbiddenVariable.IsUsedWithin(load)) return false; return true; } else { @@ -468,6 +497,8 @@ namespace ICSharpCode.Decompiler.IL.Transforms /// stloc l(compound.op.old(call get_Prop(target), ldc.i4 1)) /// /// + /// This pattern is used for post-increment by legacy csc. + /// /// Even though this transform operates only on a single expression, it's not an expression transform /// as the result value of the expression changes (this is OK only for statements in a block). /// @@ -476,24 +507,40 @@ namespace ICSharpCode.Decompiler.IL.Transforms var store = block.Instructions[pos]; if (!IsCompoundStore(store, out var targetType, out var value)) return false; + StLoc stloc; var binary = UnwrapSmallIntegerConv(value, out var conv) as BinaryNumericInstruction; - if (binary == null || !binary.Right.MatchLdcI4(1)) - return false; - if (!(binary.Operator == BinaryNumericOperator.Add || binary.Operator == BinaryNumericOperator.Sub)) + if (binary != null && binary.Right.MatchLdcI(1)) { + if (!(binary.Operator == BinaryNumericOperator.Add || binary.Operator == BinaryNumericOperator.Sub)) + return false; + if (!ValidateCompoundAssign(binary, conv, targetType)) + return false; + stloc = binary.Left as StLoc; + } else if (value is Call operatorCall && operatorCall.Method.IsOperator && operatorCall.Arguments.Count == 1) { + if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement")) + return false; + if (operatorCall.IsLifted) + return false; // TODO: add tests and think about whether nullables need special considerations + stloc = operatorCall.Arguments[0] as StLoc; + } else { return false; - if (!(binary.Left is StLoc stloc)) + } + if (stloc == null) return false; if (!(stloc.Variable.Kind == VariableKind.Local || stloc.Variable.Kind == VariableKind.StackSlot)) return false; if (!IsMatchingCompoundLoad(stloc.Value, store, stloc.Variable)) return false; - if (!ValidateCompoundAssign(binary, conv, targetType)) - return false; if (IsImplicitTruncation(stloc.Value, stloc.Variable.Type)) return false; context.Step("TransformPostIncDecOperatorWithInlineStore", store); - block.Instructions[pos] = new StLoc(stloc.Variable, new CompoundAssignmentInstruction( - binary, stloc.Value, binary.Right, targetType, CompoundAssignmentType.EvaluatesToOldValue)); + if (binary != null) { + block.Instructions[pos] = new StLoc(stloc.Variable, new NumericCompoundAssign( + binary, stloc.Value, binary.Right, targetType, CompoundAssignmentType.EvaluatesToOldValue)); + } else { + Call operatorCall = (Call)value; + block.Instructions[pos] = new StLoc(stloc.Variable, new UserDefinedCompoundAssign( + operatorCall.Method, CompoundAssignmentType.EvaluatesToOldValue, stloc.Value, new LdcI4(1))); + } return true; } @@ -515,19 +562,35 @@ namespace ICSharpCode.Decompiler.IL.Transforms return false; if (!IsCompoundStore(store, out var targetType, out var value)) return false; - if (!IsMatchingCompoundLoad(inst.Value, store, inst.Variable)) - return false; - var binary = UnwrapSmallIntegerConv(value, out var conv) as BinaryNumericInstruction; - if (binary == null || !binary.Left.MatchLdLoc(inst.Variable) || !binary.Right.MatchLdcI4(1)) - return false; - if (!(binary.Operator == BinaryNumericOperator.Add || binary.Operator == BinaryNumericOperator.Sub)) + if (IsImplicitTruncation(inst.Value, targetType)) { + // 'stloc l' is implicitly truncating the value return false; - if (!ValidateCompoundAssign(binary, conv, targetType)) + } + if (!IsMatchingCompoundLoad(inst.Value, store, inst.Variable)) return false; - if (IsImplicitTruncation(value, targetType)) + if (UnwrapSmallIntegerConv(value, out var conv) is BinaryNumericInstruction binary) { + if (!binary.Left.MatchLdLoc(inst.Variable) || !binary.Right.MatchLdcI(1)) + return false; + if (!(binary.Operator == BinaryNumericOperator.Add || binary.Operator == BinaryNumericOperator.Sub)) + return false; + if (!ValidateCompoundAssign(binary, conv, targetType)) + return false; + context.Step("TransformPostIncDecOperator (builtin)", inst); + inst.Value = new NumericCompoundAssign(binary, inst.Value, binary.Right, + targetType, CompoundAssignmentType.EvaluatesToOldValue); + } else if (value is Call operatorCall && operatorCall.Method.IsOperator && operatorCall.Arguments.Count == 1) { + if (!operatorCall.Arguments[0].MatchLdLoc(inst.Variable)) + return false; + if (!(operatorCall.Method.Name == "op_Increment" || operatorCall.Method.Name == "op_Decrement")) + return false; + if (operatorCall.IsLifted) + return false; // TODO: add tests and think about whether nullables need special considerations + context.Step("TransformPostIncDecOperator (user-defined)", inst); + inst.Value = new UserDefinedCompoundAssign(operatorCall.Method, + CompoundAssignmentType.EvaluatesToOldValue, inst.Value, new LdcI4(1)); + } else { return false; - context.Step("TransformPostIncDecOperator", inst); - inst.Value = new CompoundAssignmentInstruction(binary, inst.Value, binary.Right, targetType, CompoundAssignmentType.EvaluatesToOldValue); + } block.Instructions.RemoveAt(i + 1); if (inst.Variable.IsSingleDefinition && inst.Variable.LoadCount == 0) { // dead store -> it was a statement-level post-increment diff --git a/ICSharpCode.Decompiler/IL/Transforms/TransformExpressionTrees.cs b/ICSharpCode.Decompiler/IL/Transforms/TransformExpressionTrees.cs index 0dfe08e47..09dc63949 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/TransformExpressionTrees.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/TransformExpressionTrees.cs @@ -190,7 +190,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms var param = new ILVariable(VariableKind.Parameter, value.Item1, i) { Name = value.Item2 }; parameterMapping.Add(v, param); parameterVariables.Add(param); - parameters.Add(new DefaultUnresolvedParameter(value.Item1.ToTypeReference(), value.Item2).CreateResolvedParameter(resolveContext)); + parameters.Add(new DefaultParameter(value.Item1, value.Item2)); instructionsToRemove.Add((ILInstruction)v.StoreInstructions[0]); i++; } diff --git a/ICSharpCode.Decompiler/IL/Transforms/TupleTransform.cs b/ICSharpCode.Decompiler/IL/Transforms/TupleTransform.cs new file mode 100644 index 000000000..6e61499f1 --- /dev/null +++ b/ICSharpCode.Decompiler/IL/Transforms/TupleTransform.cs @@ -0,0 +1,93 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Text; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.IL +{ + class TupleTransform + { + /// + /// Matches an 'ldflda' instruction accessing a tuple element. + /// + /// E.g. matches: + /// ldflda Item1(ldflda Rest(target)) + /// + public static bool MatchTupleFieldAccess(LdFlda inst, out IType tupleType, out ILInstruction target, out int position) + { + tupleType = inst.Field.DeclaringType; + target = inst.Target; + if (!inst.Field.Name.StartsWith("Item", StringComparison.Ordinal)) { + position = 0; + return false; + } + if (!int.TryParse(inst.Field.Name.Substring(4), out position)) + return false; + if (!TupleType.IsTupleCompatible(tupleType, out _)) + return false; + while (target is LdFlda ldflda && ldflda.Field.Name == "Rest" && TupleType.IsTupleCompatible(ldflda.Field.DeclaringType, out _)) { + tupleType = ldflda.Field.DeclaringType; + target = ldflda.Target; + position += TupleType.RestPosition - 1; + } + return true; + } + + /// + /// Matches 'newobj TupleType(...)'. + /// Takes care of flattening long tuples. + /// + public static bool MatchTupleConstruction(NewObj newobj, out ILInstruction[] arguments) + { + arguments = null; + if (newobj == null) + return false; + if (!TupleType.IsTupleCompatible(newobj.Method.DeclaringType, out int elementCount)) + return false; + arguments = new ILInstruction[elementCount]; + int outIndex = 0; + while (elementCount >= TupleType.RestPosition) { + if (newobj.Arguments.Count != TupleType.RestPosition) + return false; + for (int pos = 1; pos < TupleType.RestPosition; pos++) { + arguments[outIndex++] = newobj.Arguments[pos-1]; + } + elementCount -= TupleType.RestPosition - 1; + Debug.Assert(outIndex + elementCount == arguments.Length); + newobj = newobj.Arguments.Last() as NewObj; + if (newobj == null) + return false; + if (!TupleType.IsTupleCompatible(newobj.Method.DeclaringType, out int restElementCount)) + return false; + if (restElementCount != elementCount) + return false; + } + Debug.Assert(outIndex + elementCount == arguments.Length); + if (newobj.Arguments.Count != elementCount) + return false; + for (int i = 0; i < elementCount; i++) { + arguments[outIndex++] = newobj.Arguments[i]; + } + return true; + } + } +} diff --git a/ICSharpCode.Decompiler/Semantics/Conversion.cs b/ICSharpCode.Decompiler/Semantics/Conversion.cs index c36a17982..49af18b3e 100644 --- a/ICSharpCode.Decompiler/Semantics/Conversion.cs +++ b/ICSharpCode.Decompiler/Semantics/Conversion.cs @@ -17,6 +17,8 @@ // DEALINGS IN THE SOFTWARE. using System; +using System.Collections.Immutable; +using System.Linq; using ICSharpCode.Decompiler.TypeSystem; namespace ICSharpCode.Decompiler.Semantics @@ -94,6 +96,11 @@ namespace ICSharpCode.Decompiler.Semantics throw new ArgumentNullException("chosenMethod"); return new MethodGroupConv(chosenMethod, isVirtualMethodLookup, delegateCapturesFirstArgument, isValid: false); } + + public static Conversion TupleConversion(ImmutableArray conversions) + { + return new TupleConv(conversions); + } #endregion #region Inner classes @@ -376,6 +383,43 @@ namespace ICSharpCode.Decompiler.Semantics return method.GetHashCode(); } } + + sealed class TupleConv : Conversion + { + public override bool IsImplicit { get; } + public override bool IsExplicit => !IsImplicit; + public override ImmutableArray ElementConversions { get; } + public override bool IsTupleConversion => true; + + public TupleConv(ImmutableArray elementConversions) + { + this.ElementConversions = elementConversions; + this.IsImplicit = elementConversions.All(c => c.IsImplicit); + } + + public override bool Equals(Conversion other) + { + return other is TupleConv o + && ElementConversions.SequenceEqual(o.ElementConversions); + } + + public override int GetHashCode() + { + unchecked { + int hash = 0; + foreach (var conv in ElementConversions) { + hash *= 31; + hash += conv.GetHashCode(); + } + return hash; + } + } + + public override string ToString() + { + return (IsImplicit ? "implicit " : "explicit ") + " tuple conversion"; + } + } #endregion /// @@ -451,7 +495,7 @@ namespace ICSharpCode.Decompiler.Semantics public virtual bool IsNullableConversion { get { return false; } } - + /// /// Gets whether this conversion is user-defined (op_Implicit or op_Explicit). /// @@ -533,7 +577,17 @@ namespace ICSharpCode.Decompiler.Semantics public virtual IMethod Method { get { return null; } } - + + /// + /// Gets whether this conversion is a tuple conversion. + /// + public virtual bool IsTupleConversion => false; + + /// + /// For a tuple conversion, gets the individual tuple element conversions. + /// + public virtual ImmutableArray ElementConversions => default(ImmutableArray); + public override sealed bool Equals(object obj) { return Equals(obj as Conversion); diff --git a/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs b/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs index 3e19a6554..f3891e297 100644 --- a/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs +++ b/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs @@ -28,7 +28,7 @@ namespace ICSharpCode.Decompiler.Semantics { readonly INamespace ns; - public NamespaceResolveResult(INamespace ns) : base(SpecialType.UnknownType) + public NamespaceResolveResult(INamespace ns) : base(SpecialType.NoType) { this.ns = ns; } diff --git a/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs b/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs new file mode 100644 index 000000000..0239db4c7 --- /dev/null +++ b/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs @@ -0,0 +1,57 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; +using System.Text; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result for a C# 7 tuple literal. + /// + public class TupleResolveResult : ResolveResult + { + public ImmutableArray Elements { get; } + + public TupleResolveResult(ICompilation compilation, + ImmutableArray elements, + ImmutableArray elementNames = default(ImmutableArray)) + : base(GetTupleType(compilation, elements, elementNames)) + { + this.Elements = elements; + } + + public override IEnumerable GetChildResults() + { + return Elements; + } + + static IType GetTupleType(ICompilation compilation, ImmutableArray elements, ImmutableArray elementNames) + { + if (elements.Any(e => e.Type.Kind == TypeKind.None || e.Type.Kind == TypeKind.Null)) + return SpecialType.NoType; + else + return new TupleType(compilation, elements.Select(e => e.Type).ToImmutableArray(), elementNames); + } + } +} diff --git a/ICSharpCode.Decompiler/TypeSystem/AnonymousType.cs b/ICSharpCode.Decompiler/TypeSystem/AnonymousType.cs index a484d02ef..8d11138f2 100644 --- a/ICSharpCode.Decompiler/TypeSystem/AnonymousType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/AnonymousType.cs @@ -106,11 +106,6 @@ namespace ICSharpCode.Decompiler.TypeSystem } } - public override ITypeReference ToTypeReference() - { - return new AnonymousTypeReference(unresolvedProperties); - } - public override string Name { get { return "Anonymous Type"; } } @@ -197,25 +192,4 @@ namespace ICSharpCode.Decompiler.TypeSystem return true; } } - - /// - /// Anonymous type reference. - /// - [Serializable] - public class AnonymousTypeReference : ITypeReference - { - readonly IUnresolvedProperty[] unresolvedProperties; - - public AnonymousTypeReference(IUnresolvedProperty[] properties) - { - if (properties == null) - throw new ArgumentNullException("properties"); - this.unresolvedProperties = properties; - } - - public IType Resolve(ITypeResolveContext context) - { - return new AnonymousType(context.Compilation, unresolvedProperties); - } - } } diff --git a/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs b/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs index 19097a148..72cd0f2bd 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs @@ -78,11 +78,6 @@ namespace ICSharpCode.Decompiler.TypeSystem return a != null && elementType.Equals(a.elementType) && a.dimensions == dimensions; } - public override ITypeReference ToTypeReference() - { - return new ArrayTypeReference(elementType.ToTypeReference(), dimensions); - } - public override IEnumerable DirectBaseTypes { get { List baseTypes = new List(); diff --git a/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs b/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs index 7f87043fd..9c4587b40 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs @@ -65,11 +65,6 @@ namespace ICSharpCode.Decompiler.TypeSystem else return new ByReferenceType(e); } - - public override ITypeReference ToTypeReference() - { - return new ByReferenceTypeReference(elementType.ToTypeReference()); - } } [Serializable] diff --git a/ICSharpCode.Decompiler/TypeSystem/CecilLoader.cs b/ICSharpCode.Decompiler/TypeSystem/CecilLoader.cs index 901bea2fd..cfd360073 100644 --- a/ICSharpCode.Decompiler/TypeSystem/CecilLoader.cs +++ b/ICSharpCode.Decompiler/TypeSystem/CecilLoader.cs @@ -18,6 +18,7 @@ using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using System.Runtime.CompilerServices; @@ -38,13 +39,6 @@ namespace ICSharpCode.Decompiler.TypeSystem /// if you want to load multiple project contents in parallel. public sealed class CecilLoader : AssemblyLoader { - /// - /// Version number of the cecil loader. - /// Should be incremented when fixing bugs in the cecil loader so that project contents cached on disk - /// (which might be incorrect due to the bug) are re-created. - /// - const int cecilLoaderVersion = 1; - #region Options // Most options are defined in the AssemblyLoader base class @@ -64,6 +58,16 @@ namespace ICSharpCode.Decompiler.TypeSystem /// public bool LazyLoad { get; set; } + /// + /// Gets/Sets whether to use the dynamic type. + /// + public bool UseDynamicType { get; set; } = true; + + /// + /// Gets/Sets whether to use the tuple types. + /// + public bool UseTupleTypes { get; set; } = true; + /// /// This delegate gets executed whenever an entity was loaded. /// @@ -75,20 +79,11 @@ namespace ICSharpCode.Decompiler.TypeSystem /// public Action OnEntityLoaded { get; set; } - bool shortenInterfaceImplNames = true; - /// /// Specifies whether method names of explicit interface-implementations should be shortened. /// /// This is important when working with parser-initialized type-systems in order to be consistent. - public bool ShortenInterfaceImplNames { - get { - return shortenInterfaceImplNames; - } - set { - shortenInterfaceImplNames = value; - } - } + public bool ShortenInterfaceImplNames { get; set; } = true; #endregion ModuleDefinition currentModule; @@ -108,6 +103,8 @@ namespace ICSharpCode.Decompiler.TypeSystem { // use a shared typeSystemTranslationTable this.IncludeInternalMembers = loader.IncludeInternalMembers; + this.UseDynamicType = loader.UseDynamicType; + this.UseTupleTypes = loader.UseTupleTypes; this.LazyLoad = loader.LazyLoad; this.OnEntityLoaded = loader.OnEntityLoaded; this.ShortenInterfaceImplNames = loader.ShortenInterfaceImplNames; @@ -295,11 +292,12 @@ namespace ICSharpCode.Decompiler.TypeSystem /// IsValueType is set correctly. public ITypeReference ReadTypeReference(TypeReference type, ICustomAttributeProvider typeAttributes = null, bool isFromSignature = false) { - int typeIndex = 0; - return CreateType(type, typeAttributes, ref typeIndex, isFromSignature); + int dynamicTypeIndex = 0; + int tupleTypeIndex = 0; + return CreateType(type, typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature); } - ITypeReference CreateType(TypeReference type, ICustomAttributeProvider typeAttributes, ref int typeIndex, bool isFromSignature) + ITypeReference CreateType(TypeReference type, ICustomAttributeProvider typeAttributes, ref int dynamicTypeIndex, ref int tupleTypeIndex, bool isFromSignature) { if (type == null) { return SpecialType.UnknownType; @@ -307,90 +305,123 @@ namespace ICSharpCode.Decompiler.TypeSystem switch (type.MetadataType) { case MetadataType.Void: - return KnownTypeReference.Get(KnownTypeCode.Void); + return KnownTypeReference.Void; case MetadataType.Boolean: - return KnownTypeReference.Get(KnownTypeCode.Boolean); + return KnownTypeReference.Boolean; case MetadataType.Char: - return KnownTypeReference.Get(KnownTypeCode.Char); + return KnownTypeReference.Char; case MetadataType.SByte: - return KnownTypeReference.Get(KnownTypeCode.SByte); + return KnownTypeReference.SByte; case MetadataType.Byte: - return KnownTypeReference.Get(KnownTypeCode.Byte); + return KnownTypeReference.Byte; case MetadataType.Int16: - return KnownTypeReference.Get(KnownTypeCode.Int16); + return KnownTypeReference.Int16; case MetadataType.UInt16: - return KnownTypeReference.Get(KnownTypeCode.UInt16); + return KnownTypeReference.UInt16; case MetadataType.Int32: - return KnownTypeReference.Get(KnownTypeCode.Int32); + return KnownTypeReference.Int32; case MetadataType.UInt32: - return KnownTypeReference.Get(KnownTypeCode.UInt32); + return KnownTypeReference.UInt32; case MetadataType.Int64: - return KnownTypeReference.Get(KnownTypeCode.Int64); + return KnownTypeReference.Int64; case MetadataType.UInt64: - return KnownTypeReference.Get(KnownTypeCode.UInt64); + return KnownTypeReference.UInt64; case MetadataType.Single: - return KnownTypeReference.Get(KnownTypeCode.Single); + return KnownTypeReference.Single; case MetadataType.Double: - return KnownTypeReference.Get(KnownTypeCode.Double); + return KnownTypeReference.Double; case MetadataType.String: - return KnownTypeReference.Get(KnownTypeCode.String); + return KnownTypeReference.String; case MetadataType.Pointer: - typeIndex++; + dynamicTypeIndex++; return interningProvider.Intern( new PointerTypeReference( CreateType( (type as Mono.Cecil.PointerType).ElementType, - typeAttributes, ref typeIndex, isFromSignature: true))); + typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true))); case MetadataType.ByReference: - typeIndex++; + dynamicTypeIndex++; return interningProvider.Intern( new ByReferenceTypeReference( CreateType( (type as Mono.Cecil.ByReferenceType).ElementType, - typeAttributes, ref typeIndex, isFromSignature: true))); + typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true))); case MetadataType.Var: return TypeParameterReference.Create(SymbolKind.TypeDefinition, ((GenericParameter)type).Position); case MetadataType.MVar: return TypeParameterReference.Create(SymbolKind.Method, ((GenericParameter)type).Position); case MetadataType.Array: - typeIndex++; + dynamicTypeIndex++; return interningProvider.Intern( new ArrayTypeReference( CreateType( (type as Mono.Cecil.ArrayType).ElementType, - typeAttributes, ref typeIndex, isFromSignature: true), + typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true), (type as Mono.Cecil.ArrayType).Rank)); case MetadataType.GenericInstance: GenericInstanceType gType = (GenericInstanceType)type; - ITypeReference baseType = CreateType(gType.ElementType, typeAttributes, ref typeIndex, isFromSignature: true); + ITypeReference baseType = CreateType(gType.ElementType, typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true); + if (UseTupleTypes && IsValueTuple(gType, out int tupleCardinality)) { + if (tupleCardinality > 1) { + var assemblyRef = GetAssemblyReference(gType.ElementType.Scope); + var elementNames = GetTupleElementNames(typeAttributes, tupleTypeIndex, tupleCardinality); + tupleTypeIndex += tupleCardinality; + ITypeReference[] elementTypeRefs = new ITypeReference[tupleCardinality]; + int outPos = 0; + do { + int normalArgCount = Math.Min(gType.GenericArguments.Count, TupleType.RestPosition - 1); + for (int i = 0; i < normalArgCount; i++) { + dynamicTypeIndex++; + elementTypeRefs[outPos++] = CreateType(gType.GenericArguments[i], typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true); + } + if (gType.GenericArguments.Count == TupleType.RestPosition) { + gType = (GenericInstanceType)gType.GenericArguments.Last(); + dynamicTypeIndex++; + if (IsValueTuple(gType, out int nestedCardinality)) { + tupleTypeIndex += nestedCardinality; + } else { + Debug.Fail("TRest should be another value tuple"); + } + } else { + gType = null; + } + } while (gType != null); + return new TupleTypeReference( + elementTypeRefs.ToImmutableArray(), elementNames, + assemblyRef); + } else { + // C# doesn't have syntax for tuples of cardinality <= 1 + tupleTypeIndex += tupleCardinality; + } + } ITypeReference[] para = new ITypeReference[gType.GenericArguments.Count]; for (int i = 0; i < para.Length; ++i) { - typeIndex++; - para[i] = CreateType(gType.GenericArguments[i], typeAttributes, ref typeIndex, isFromSignature: true); + dynamicTypeIndex++; + para[i] = CreateType(gType.GenericArguments[i], typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true); } return interningProvider.Intern(new ParameterizedTypeReference(baseType, para)); case MetadataType.IntPtr: - return KnownTypeReference.Get(KnownTypeCode.IntPtr); + return KnownTypeReference.IntPtr; case MetadataType.UIntPtr: - return KnownTypeReference.Get(KnownTypeCode.UIntPtr); + return KnownTypeReference.UIntPtr; case MetadataType.FunctionPointer: // C# and the NR typesystem don't support function pointer types. // Function pointer types map to StackType.I, so we'll use IntPtr instead. - return KnownTypeReference.Get(KnownTypeCode.IntPtr); + return KnownTypeReference.IntPtr; case MetadataType.Object: - if (HasDynamicAttribute(typeAttributes, typeIndex)) { + if (UseDynamicType && HasDynamicAttribute(typeAttributes, dynamicTypeIndex)) { return SpecialType.Dynamic; } else { - return KnownTypeReference.Get(KnownTypeCode.Object); + return KnownTypeReference.Object; } case MetadataType.RequiredModifier: case MetadataType.OptionalModifier: // we don't store modopts/modreqs in the NR type system - return CreateType(((TypeSpecification)type).ElementType, typeAttributes, ref typeIndex, isFromSignature: true); + return CreateType(((TypeSpecification)type).ElementType, typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true); case MetadataType.Sentinel: return SpecialType.ArgList; case MetadataType.Pinned: - return CreateType(((PinnedType)type).ElementType, typeAttributes, ref typeIndex, isFromSignature: true); + return CreateType(((PinnedType)type).ElementType, typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature: true); } // valuetype/class/typedbyreference if (type is TypeDefinition) { @@ -400,7 +431,7 @@ namespace ICSharpCode.Decompiler.TypeSystem // or if it's a TypeSpecification. bool? isReferenceType = isFromSignature ? (bool?)!type.IsValueType : null; if (type.IsNested) { - ITypeReference typeRef = CreateType(type.DeclaringType, typeAttributes, ref typeIndex, isFromSignature); + ITypeReference typeRef = CreateType(type.DeclaringType, typeAttributes, ref dynamicTypeIndex, ref tupleTypeIndex, isFromSignature); int partTypeParameterCount; string namepart = ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name, out partTypeParameterCount); namepart = interningProvider.Intern(namepart); @@ -411,7 +442,7 @@ namespace ICSharpCode.Decompiler.TypeSystem if (name == null) throw new InvalidOperationException("type.Name returned null. Type: " + type.ToString()); - if (name == "Object" && ns == "System" && HasDynamicAttribute(typeAttributes, typeIndex)) { + if (UseDynamicType && name == "Object" && ns == "System" && HasDynamicAttribute(typeAttributes, dynamicTypeIndex)) { return SpecialType.Dynamic; } int typeParameterCount; @@ -422,7 +453,46 @@ namespace ICSharpCode.Decompiler.TypeSystem isReferenceType)); } } - + + static internal bool IsValueTuple(GenericInstanceType gType, out int tupleCardinality) + { + tupleCardinality = 0; + if (gType == null || gType.DeclaringType != null || !gType.Name.StartsWith("ValueTuple`", StringComparison.Ordinal) || gType.Namespace != "System") + return false; + if (gType.GenericArguments.Count == TupleType.RestPosition) { + if (IsValueTuple(gType.GenericArguments.Last() as GenericInstanceType, out tupleCardinality)) { + tupleCardinality += TupleType.RestPosition - 1; + return true; + } + } + tupleCardinality = gType.GenericArguments.Count; + return tupleCardinality > 0 && tupleCardinality < TupleType.RestPosition; + } + + static ImmutableArray GetTupleElementNames(ICustomAttributeProvider attributeProvider, int tupleTypeIndex, int tupleCardinality) + { + if (attributeProvider == null || !attributeProvider.HasCustomAttributes) + return default(ImmutableArray); + foreach (CustomAttribute a in attributeProvider.CustomAttributes) { + TypeReference type = a.AttributeType; + if (type.Name == "TupleElementNamesAttribute" && type.Namespace == "System.Runtime.CompilerServices") { + if (a.ConstructorArguments.Count == 1) { + CustomAttributeArgument[] values = a.ConstructorArguments[0].Value as CustomAttributeArgument[]; + if (values != null) { + string[] extractedValues = new string[tupleCardinality]; + for (int i = 0; i < tupleCardinality; i++) { + if (tupleTypeIndex + i < values.Length) { + extractedValues[i] = values[tupleTypeIndex + i].Value as string; + } + } + return extractedValues.ToImmutableArray(); + } + } + } + } + return default(ImmutableArray); + } + IAssemblyReference GetAssemblyReference(IMetadataScope scope) { if (scope == null || scope == currentModule) @@ -827,7 +897,11 @@ namespace ICSharpCode.Decompiler.TypeSystem foreach (var cecilAttribute in attributes) { TypeReference type = cecilAttribute.AttributeType; if (type.Namespace == "System.Runtime.CompilerServices") { - if (type.Name == "DynamicAttribute" || type.Name == "ExtensionAttribute" || type.Name == "DecimalConstantAttribute") + if (type.Name == "ExtensionAttribute" || type.Name == "DecimalConstantAttribute") + continue; + if (UseDynamicType && type.Name == "DynamicAttribute") + continue; + if (UseTupleTypes && type.Name == "TupleElementNamesAttribute") continue; } else if (type.Name == "ParamArrayAttribute" && type.Namespace == "System") { continue; diff --git a/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs b/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs index a52e4f64e..74ab04225 100644 --- a/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs +++ b/ICSharpCode.Decompiler/TypeSystem/DecompilerTypeSystem.cs @@ -23,7 +23,7 @@ namespace ICSharpCode.Decompiler.TypeSystem /// CecilLoader used for converting cecil type references to ITypeReference. /// May only be accessed within lock(typeReferenceCecilLoader). /// - readonly CecilLoader typeReferenceCecilLoader = new CecilLoader(); + readonly CecilLoader typeReferenceCecilLoader; /// /// Dictionary for NRefactory->Cecil lookup. @@ -35,13 +35,30 @@ namespace ICSharpCode.Decompiler.TypeSystem Dictionary propertyLookupCache = new Dictionary(); Dictionary methodLookupCache = new Dictionary(); Dictionary eventLookupCache = new Dictionary(); - - public DecompilerTypeSystem(ModuleDefinition moduleDefinition) + + public DecompilerTypeSystem(ModuleDefinition moduleDefinition) : this(moduleDefinition, new DecompilerSettings()) + { + } + + public DecompilerTypeSystem(ModuleDefinition moduleDefinition, DecompilerSettings settings) { if (moduleDefinition == null) throw new ArgumentNullException(nameof(moduleDefinition)); + if (settings == null) + throw new ArgumentNullException(nameof(settings)); this.moduleDefinition = moduleDefinition; - CecilLoader cecilLoader = new CecilLoader { IncludeInternalMembers = true, LazyLoad = true, OnEntityLoaded = StoreMemberReference, ShortenInterfaceImplNames = false }; + typeReferenceCecilLoader = new CecilLoader { + UseDynamicType = settings.Dynamic, + UseTupleTypes = settings.TupleTypes, + }; + CecilLoader cecilLoader = new CecilLoader { + IncludeInternalMembers = true, + LazyLoad = true, + OnEntityLoaded = StoreMemberReference, + ShortenInterfaceImplNames = false, + UseDynamicType = settings.Dynamic, + UseTupleTypes = settings.TupleTypes, + }; typeReferenceCecilLoader.SetCurrentModule(moduleDefinition); IUnresolvedAssembly mainAssembly = cecilLoader.LoadModule(moduleDefinition); // Load referenced assemblies and type-forwarder references. @@ -294,11 +311,16 @@ namespace ICSharpCode.Decompiler.TypeSystem } return CreateFakeMethod(methodReference); } - + + static readonly NormalizeTypeVisitor normalizeTypeVisitor = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = true, + ReplaceMethodTypeParametersWithDummy = true, + }; + static bool CompareTypes(IType a, IType b) { - IType type1 = DummyTypeParameter.NormalizeAllTypeParameters(a); - IType type2 = DummyTypeParameter.NormalizeAllTypeParameters(b); + IType type1 = a.AcceptVisitor(normalizeTypeVisitor); + IType type2 = b.AcceptVisitor(normalizeTypeVisitor); return type1.Equals(type2); } diff --git a/ICSharpCode.Decompiler/TypeSystem/DefaultSolutionSnapshot.cs b/ICSharpCode.Decompiler/TypeSystem/DefaultSolutionSnapshot.cs deleted file mode 100644 index 9aaa9d998..000000000 --- a/ICSharpCode.Decompiler/TypeSystem/DefaultSolutionSnapshot.cs +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team -// -// Permission is hereby granted, free of charge, to any person obtaining a copy of this -// software and associated documentation files (the "Software"), to deal in the Software -// without restriction, including without limitation the rights to use, copy, modify, merge, -// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons -// to whom the Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all copies or -// substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, -// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE -// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -using System; -using System.Collections.Concurrent; -using System.Collections.Generic; -using ICSharpCode.Decompiler.Util; - -namespace ICSharpCode.Decompiler.TypeSystem -{ - /// - /// Default implementation of ISolutionSnapshot. - /// - public class DefaultSolutionSnapshot : ISolutionSnapshot - { - readonly Dictionary projectDictionary = new Dictionary(Platform.FileNameComparer); - ConcurrentDictionary dictionary = new ConcurrentDictionary(); - - /// - /// Creates a new DefaultSolutionSnapshot with the specified projects. - /// - public DefaultSolutionSnapshot(IEnumerable projects) - { - foreach (var project in projects) { - if (project.ProjectFileName != null) - projectDictionary.Add(project.ProjectFileName, project); - } - } - - /// - /// Creates a new DefaultSolutionSnapshot that does not support s. - /// - public DefaultSolutionSnapshot() - { - } - - public IProjectContent GetProjectContent(string projectFileName) - { - IProjectContent pc; - lock (projectDictionary) { - if (projectDictionary.TryGetValue(projectFileName, out pc)) - return pc; - else - return null; - } - } - - public ICompilation GetCompilation(IProjectContent project) - { - if (project == null) - throw new ArgumentNullException("project"); - return dictionary.GetOrAdd(project, p => p.CreateCompilation(this)); - } - - public void AddCompilation(IProjectContent project, ICompilation compilation) - { - if (project == null) - throw new ArgumentNullException("project"); - if (compilation == null) - throw new ArgumentNullException("compilation"); - if (!dictionary.TryAdd(project, compilation)) - throw new InvalidOperationException(); - if (project.ProjectFileName != null) { - lock (projectDictionary) { - projectDictionary.Add(project.ProjectFileName, project); - } - } - } - } -} diff --git a/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs b/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs index 2a8c3b3c7..abd79c807 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs +++ b/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs @@ -75,8 +75,6 @@ namespace ICSharpCode.Decompiler.TypeSystem /// StringComparer NameComparer { get; } - ISolutionSnapshot SolutionSnapshot { get; } - CacheManager CacheManager { get; } } diff --git a/ICSharpCode.Decompiler/TypeSystem/IMember.cs b/ICSharpCode.Decompiler/TypeSystem/IMember.cs index ad1e46e51..cd8376c30 100644 --- a/ICSharpCode.Decompiler/TypeSystem/IMember.cs +++ b/ICSharpCode.Decompiler/TypeSystem/IMember.cs @@ -172,5 +172,10 @@ namespace ICSharpCode.Decompiler.TypeSystem /// If this member is already specialized, the new substitution is composed with the existing substition. /// IMember Specialize(TypeParameterSubstitution substitution); + + /// + /// Gets whether the members are considered equal when applying the specified type normalization. + /// + bool Equals(IMember obj, TypeVisitor typeNormalization); } } diff --git a/ICSharpCode.Decompiler/TypeSystem/IProjectContent.cs b/ICSharpCode.Decompiler/TypeSystem/IProjectContent.cs deleted file mode 100644 index 0806033e9..000000000 --- a/ICSharpCode.Decompiler/TypeSystem/IProjectContent.cs +++ /dev/null @@ -1,146 +0,0 @@ -// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team -// -// Permission is hereby granted, free of charge, to any person obtaining a copy of this -// software and associated documentation files (the "Software"), to deal in the Software -// without restriction, including without limitation the rights to use, copy, modify, merge, -// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons -// to whom the Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all copies or -// substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, -// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE -// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. - -using System; -using System.Collections.Generic; - -namespace ICSharpCode.Decompiler.TypeSystem -{ - /// - /// Represents an assembly consisting of source code (parsed files). - /// - public interface IProjectContent : IUnresolvedAssembly - { - /// - /// Gets the path to the project file (e.g. .csproj). - /// - string ProjectFileName { get; } - - /// - /// Gets a parsed file by its file name. - /// - IUnresolvedFile GetFile(string fileName); - - /// - /// Gets the list of all files in the project content. - /// - IEnumerable Files { get; } - - /// - /// Gets the referenced assemblies. - /// - IEnumerable AssemblyReferences { get; } - - /// - /// Gets the compiler settings object. - /// The concrete type of the settings object depends on the programming language used to implement this project. - /// - object CompilerSettings { get; } - - /// - /// Creates a new that allows resolving within this project. - /// - /// - /// This method does not support s. When dealing with a solution - /// containing multiple projects, consider using instead. - /// - ICompilation CreateCompilation(); - - /// - /// Creates a new that allows resolving within this project. - /// - /// The parent solution snapshot to use for the compilation. - /// - /// This method is intended to be called by ISolutionSnapshot implementations. Other code should - /// call instead. - /// This method always creates a new compilation, even if the solution snapshot already contains - /// one for this project. - /// - ICompilation CreateCompilation(ISolutionSnapshot solutionSnapshot); - - /// - /// Changes the assembly name of this project content. - /// - IProjectContent SetAssemblyName(string newAssemblyName); - - /// - /// Changes the project file name of this project content. - /// - IProjectContent SetProjectFileName(string newProjectFileName); - - /// - /// Changes the path to the assembly location (the output path where the project compiles to). - /// - IProjectContent SetLocation(string newLocation); - - /// - /// Add assembly references to this project content. - /// - IProjectContent AddAssemblyReferences(IEnumerable references); - - /// - /// Add assembly references to this project content. - /// - IProjectContent AddAssemblyReferences(params IAssemblyReference[] references); - - /// - /// Removes assembly references from this project content. - /// - IProjectContent RemoveAssemblyReferences(IEnumerable references); - - /// - /// Removes assembly references from this project content. - /// - IProjectContent RemoveAssemblyReferences(params IAssemblyReference[] references); - - /// - /// Adds the specified files to the project content. - /// If a file with the same name already exists, updated the existing file. - /// - /// - /// You can create an unresolved file by calling ToTypeSystem() on a syntax tree. - /// - IProjectContent AddOrUpdateFiles(IEnumerable newFiles); - - /// - /// Adds the specified files to the project content. - /// If a file with the same name already exists, this method updates the existing file. - /// - /// - /// You can create an unresolved file by calling ToTypeSystem() on a syntax tree. - /// - IProjectContent AddOrUpdateFiles(params IUnresolvedFile[] newFiles); - - /// - /// Removes the files with the specified names. - /// - IProjectContent RemoveFiles(IEnumerable fileNames); - - /// - /// Removes the files with the specified names. - /// - IProjectContent RemoveFiles(params string[] fileNames); - - /// - /// Sets the compiler settings object. - /// The concrete type of the settings object depends on the programming language used to implement this project. - /// Using the incorrect type of settings object results in an . - /// - IProjectContent SetCompilerSettings(object compilerSettings); - } -} diff --git a/ICSharpCode.Decompiler/TypeSystem/IType.cs b/ICSharpCode.Decompiler/TypeSystem/IType.cs index 39ab79163..d7ebaa4bc 100644 --- a/ICSharpCode.Decompiler/TypeSystem/IType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/IType.cs @@ -115,15 +115,6 @@ namespace ICSharpCode.Decompiler.TypeSystem /// Returns the direct base types including interfaces IEnumerable DirectBaseTypes { get; } - /// - /// Creates a type reference that can be used to look up a type equivalent to this type in another compilation. - /// - /// - /// If this type contains open generics, the resulting type reference will need to be looked up in an appropriate generic context. - /// Otherwise, the main resolve context of a compilation is sufficient. - /// - ITypeReference ToTypeReference(); - /// /// Gets a type visitor that performs the substitution of class type parameters with the type arguments /// of this parameterized type. diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractResolvedMember.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractResolvedMember.cs index d930a6ec9..3a7eba2c6 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractResolvedMember.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractResolvedMember.cs @@ -111,6 +111,11 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation get { return TypeParameterSubstitution.Identity; } } + public virtual bool Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + public abstract IMember Specialize(TypeParameterSubstitution substitution); internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs index 0562f7bfb..9273b2202 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs @@ -80,8 +80,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation get { return EmptyList.Instance; } } - public abstract ITypeReference ToTypeReference(); - public virtual IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) { return EmptyList.Instance; diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultMemberReference.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultMemberReference.cs index 1da5bd448..46210b199 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultMemberReference.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultMemberReference.cs @@ -57,7 +57,9 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation public ITypeReference DeclaringTypeReference { get { return typeReference; } } - + + static readonly NormalizeTypeVisitor normalizeTypeVisitor = new NormalizeTypeVisitor(); + public IMember Resolve(ITypeResolveContext context) { IType type = typeReference.Resolve(context); @@ -85,8 +87,8 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation } else if (parameterTypes.Count == parameterizedMember.Parameters.Count) { bool signatureMatches = true; for (int i = 0; i < parameterTypes.Count; i++) { - IType type1 = DummyTypeParameter.NormalizeAllTypeParameters(resolvedParameterTypes[i]); - IType type2 = DummyTypeParameter.NormalizeAllTypeParameters(parameterizedMember.Parameters[i].Type); + IType type1 = resolvedParameterTypes[i].AcceptVisitor(normalizeTypeVisitor); + IType type2 = parameterizedMember.Parameters[i].Type.AcceptVisitor(normalizeTypeVisitor); if (!type1.Equals(type2)) { signatureMatches = false; break; diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs index bfa34941b..dafca5ff6 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs @@ -615,24 +615,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation return this; } - public ITypeReference ToTypeReference() - { - ITypeDefinition declTypeDef = this.DeclaringTypeDefinition; - if (declTypeDef != null) { - return new NestedTypeReference(declTypeDef.ToTypeReference(), - this.Name, this.TypeParameterCount - declTypeDef.TypeParameterCount, - this.IsReferenceType); - } else { - IAssembly asm = this.ParentAssembly; - IAssemblyReference asmRef; - if (asm != null) - asmRef = new DefaultAssemblyReference(asm.AssemblyName); - else - asmRef = null; - return new GetClassTypeReference(asmRef, this.Namespace, this.Name, this.TypeParameterCount, this.IsReferenceType); - } - } - public IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) { const GetMemberOptions opt = GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions; diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs index 0b838a03a..cb0f2bd71 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs @@ -93,62 +93,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation } return tps[length]; } - - sealed class NormalizeMethodTypeParametersVisitor : TypeVisitor - { - public override IType VisitTypeParameter(ITypeParameter type) - { - if (type.OwnerType == SymbolKind.Method) { - return DummyTypeParameter.GetMethodTypeParameter(type.Index); - } else { - return base.VisitTypeParameter(type); - } - } - } - sealed class NormalizeClassTypeParametersVisitor : TypeVisitor - { - public override IType VisitTypeParameter(ITypeParameter type) - { - if (type.OwnerType == SymbolKind.TypeDefinition) { - return DummyTypeParameter.GetClassTypeParameter(type.Index); - } else { - return base.VisitTypeParameter(type); - } - } - } - - static readonly NormalizeMethodTypeParametersVisitor normalizeMethodTypeParameters = new NormalizeMethodTypeParametersVisitor(); - static readonly NormalizeClassTypeParametersVisitor normalizeClassTypeParameters = new NormalizeClassTypeParametersVisitor(); - - /// - /// Replaces all occurrences of method type parameters in the given type - /// by normalized type parameters. This allows comparing parameter types from different - /// generic methods. - /// - public static IType NormalizeMethodTypeParameters(IType type) - { - return type.AcceptVisitor(normalizeMethodTypeParameters); - } - - /// - /// Replaces all occurrences of class type parameters in the given type - /// by normalized type parameters. This allows comparing parameter types from different - /// generic methods. - /// - public static IType NormalizeClassTypeParameters(IType type) - { - return type.AcceptVisitor(normalizeClassTypeParameters); - } - - /// - /// Replaces all occurrences of class and method type parameters in the given type - /// by normalized type parameters. This allows comparing parameter types from different - /// generic methods. - /// - public static IType NormalizeAllTypeParameters(IType type) - { - return type.AcceptVisitor(normalizeClassTypeParameters).AcceptVisitor(normalizeMethodTypeParameters); - } readonly SymbolKind ownerType; readonly int index; @@ -188,11 +132,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation get { return TypeKind.TypeParameter; } } - public override ITypeReference ToTypeReference() - { - return TypeParameterReference.Create(ownerType, index); - } - public override IType AcceptVisitor(TypeVisitor visitor) { return visitor.VisitTypeParameter(this); diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs index 52688763f..2bbfb1fa6 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs @@ -34,7 +34,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation public ICompilation CreateCompilation() { - return new SimpleCompilation(new DefaultSolutionSnapshot(), this); + return new SimpleCompilation(this); } private MinimalCorlib() : base("corlib") diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs index 944ca2c5c..607258166 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs @@ -27,7 +27,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation /// public class SimpleCompilation : ICompilation { - readonly ISolutionSnapshot solutionSnapshot; readonly ITypeResolveContext context; readonly CacheManager cacheManager = new CacheManager(); readonly KnownTypeCache knownTypeCache; @@ -37,29 +36,16 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation INamespace rootNamespace; public SimpleCompilation(IUnresolvedAssembly mainAssembly, params IAssemblyReference[] assemblyReferences) - : this(new DefaultSolutionSnapshot(), mainAssembly, (IEnumerable)assemblyReferences) + : this(mainAssembly, (IEnumerable)assemblyReferences) { } public SimpleCompilation(IUnresolvedAssembly mainAssembly, IEnumerable assemblyReferences) - : this(new DefaultSolutionSnapshot(), mainAssembly, assemblyReferences) { - } - - public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, params IAssemblyReference[] assemblyReferences) - : this(solutionSnapshot, mainAssembly, (IEnumerable)assemblyReferences) - { - } - - public SimpleCompilation(ISolutionSnapshot solutionSnapshot, IUnresolvedAssembly mainAssembly, IEnumerable assemblyReferences) - { - if (solutionSnapshot == null) - throw new ArgumentNullException("solutionSnapshot"); if (mainAssembly == null) throw new ArgumentNullException("mainAssembly"); if (assemblyReferences == null) throw new ArgumentNullException("assemblyReferences"); - this.solutionSnapshot = solutionSnapshot; this.context = new SimpleTypeResolveContext(this); this.mainAssembly = mainAssembly.Resolve(context); List assemblies = new List(); @@ -156,10 +142,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation get { return StringComparer.Ordinal; } } - public ISolutionSnapshot SolutionSnapshot { - get { return solutionSnapshot; } - } - public override string ToString() { return "[SimpleCompilation " + mainAssembly.AssemblyName + "]"; diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs index 86ed53812..369c0c119 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs @@ -258,6 +258,15 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation return baseMember.Specialize(TypeParameterSubstitution.Compose(newSubstitution, this.substitution)); } + public virtual bool Equals(IMember obj, TypeVisitor typeNormalization) + { + SpecializedMember other = obj as SpecializedMember; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember, typeNormalization) + && this.substitution.Equals(other.substitution, typeNormalization); + } + public override bool Equals(object obj) { SpecializedMember other = obj as SpecializedMember; @@ -303,7 +312,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation if (result != null) return result; else - return LazyInit.GetOrSet(ref this.parameters, CreateParameters(this.Substitution)); + return LazyInit.GetOrSet(ref this.parameters, CreateParameters(t => t.AcceptVisitor(this.Substitution))); } protected set { // This setter is used for LiftedUserDefinedOperator, a special case of specialized member @@ -315,7 +324,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation } } - protected IParameter[] CreateParameters(TypeVisitor substitution) + protected IParameter[] CreateParameters(Func substitution) { var paramDefs = ((IParameterizedMember)this.baseMember).Parameters; if (paramDefs.Count == 0) { @@ -324,7 +333,7 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation var parameters = new IParameter[paramDefs.Count]; for (int i = 0; i < parameters.Length; i++) { var p = paramDefs[i]; - IType newType = p.Type.AcceptVisitor(substitution); + IType newType = substitution(p.Type); parameters[i] = new DefaultParameter( newType, p.Name, this, p.Attributes, p.IsRef, p.IsOut, diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs index fda5f6983..b5e23c2bc 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs @@ -147,7 +147,16 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation accessorOwner = value; } } - + + public override bool Equals(IMember obj, TypeVisitor typeNormalization) + { + SpecializedMethod other = obj as SpecializedMethod; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember, typeNormalization) + && this.substitutionWithoutSpecializedTypeParameters.Equals(other.substitutionWithoutSpecializedTypeParameters, typeNormalization); + } + public override bool Equals(object obj) { SpecializedMethod other = obj as SpecializedMethod; diff --git a/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs b/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs index e1ffdb6b4..55c8aca94 100644 --- a/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs @@ -68,11 +68,6 @@ namespace ICSharpCode.Decompiler.TypeSystem.Implementation get { return TypeKind.Unknown; } } - public override ITypeReference ToTypeReference() - { - return this; - } - IType ITypeReference.Resolve(ITypeResolveContext context) { if (context == null) diff --git a/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs b/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs index 95aef2180..b98828e0c 100644 --- a/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs @@ -126,11 +126,6 @@ namespace ICSharpCode.Decompiler.TypeSystem get { return types; } } - public override ITypeReference ToTypeReference() - { - throw new NotSupportedException(); - } - public override IEnumerable GetMethods(Predicate filter, GetMemberOptions options) { return GetMembersHelper.GetMethods(this, FilterNonStatic(filter), options); diff --git a/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs b/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs new file mode 100644 index 000000000..b40ad09ef --- /dev/null +++ b/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Text; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + sealed class NormalizeTypeVisitor : TypeVisitor + { + /// + /// NormalizeTypeVisitor that does not normalize type parameters, + /// but performs type erasure (object->dynamic; tuple->underlying type). + /// + internal static readonly NormalizeTypeVisitor TypeErasure = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = false, + ReplaceMethodTypeParametersWithDummy = false, + DynamicAndObject = true, + TupleToUnderlyingType = true + }; + + public bool ReplaceClassTypeParametersWithDummy = true; + public bool ReplaceMethodTypeParametersWithDummy = true; + public bool DynamicAndObject = true; + public bool TupleToUnderlyingType = true; + + public override IType VisitTypeParameter(ITypeParameter type) + { + if (type.OwnerType == SymbolKind.Method && ReplaceMethodTypeParametersWithDummy) { + return DummyTypeParameter.GetMethodTypeParameter(type.Index); + } else if (type.OwnerType == SymbolKind.TypeDefinition && ReplaceClassTypeParametersWithDummy) { + return DummyTypeParameter.GetClassTypeParameter(type.Index); + } else { + return base.VisitTypeParameter(type); + } + } + + public override IType VisitTypeDefinition(ITypeDefinition type) + { + if (DynamicAndObject && type.KnownTypeCode == KnownTypeCode.Object) { + // Instead of normalizing dynamic->object, + // we do this the opposite direction, so that we don't need a compilation to find the object type. + return SpecialType.Dynamic; + } + return base.VisitTypeDefinition(type); + } + + public override IType VisitTupleType(TupleType type) + { + if (TupleToUnderlyingType) { + return type.UnderlyingType.AcceptVisitor(this); + } else { + return base.VisitTupleType(type); + } + } + } +} diff --git a/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs b/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs index 3ceee3306..2c50bef7b 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs +++ b/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs @@ -34,27 +34,13 @@ namespace ICSharpCode.Decompiler.TypeSystem public sealed class ParameterListComparer : IEqualityComparer> { public static readonly ParameterListComparer Instance = new ParameterListComparer(); - - sealed class NormalizeTypeVisitor : TypeVisitor - { - public override IType VisitTypeParameter(ITypeParameter type) - { - if (type.OwnerType == SymbolKind.Method) { - return DummyTypeParameter.GetMethodTypeParameter(type.Index); - } else { - return base.VisitTypeParameter(type); - } - } - - public override IType VisitTypeDefinition(ITypeDefinition type) - { - if (type.KnownTypeCode == KnownTypeCode.Object) - return SpecialType.Dynamic; - return base.VisitTypeDefinition(type); - } - } - - static readonly NormalizeTypeVisitor normalizationVisitor = new NormalizeTypeVisitor(); + + static readonly NormalizeTypeVisitor normalizationVisitor = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = false, + ReplaceMethodTypeParametersWithDummy = true, + DynamicAndObject = true, + TupleToUnderlyingType = true, + }; public bool Equals(IReadOnlyList x, IReadOnlyList y) { diff --git a/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs b/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs index 61ebbfe7b..675a30c9e 100644 --- a/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs @@ -158,11 +158,6 @@ namespace ICSharpCode.Decompiler.TypeSystem return genericType as ITypeDefinition; } - public ITypeReference ToTypeReference() - { - return new ParameterizedTypeReference(genericType.ToTypeReference(), typeArguments.Select(t => t.ToTypeReference())); - } - /// /// Gets a type visitor that performs the substitution of class type parameters with the type arguments /// of this parameterized type. @@ -276,6 +271,8 @@ namespace ICSharpCode.Decompiler.TypeSystem public bool Equals(IType other) { + if (this == other) + return true; ParameterizedType c = other as ParameterizedType; if (c == null || !genericType.Equals(c.genericType) || typeArguments.Length != c.typeArguments.Length) return false; diff --git a/ICSharpCode.Decompiler/TypeSystem/PointerType.cs b/ICSharpCode.Decompiler/TypeSystem/PointerType.cs index 108ed32a7..048f63a02 100644 --- a/ICSharpCode.Decompiler/TypeSystem/PointerType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/PointerType.cs @@ -65,11 +65,6 @@ namespace ICSharpCode.Decompiler.TypeSystem else return new PointerType(e); } - - public override ITypeReference ToTypeReference() - { - return new PointerTypeReference(elementType.ToTypeReference()); - } } [Serializable] diff --git a/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs b/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs index aa29065c9..b7f07acdf 100644 --- a/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs +++ b/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs @@ -36,7 +36,12 @@ namespace ICSharpCode.Decompiler.TypeSystem /// The null type is used as type of the null literal. It is a reference type without any members; and it is a subtype of all reference types. /// public readonly static SpecialType NullType = new SpecialType(TypeKind.Null, "null", isReferenceType: true); - + + /// + /// Used for expressions without type, e.g. method groups or lambdas. + /// + public readonly static SpecialType NoType = new SpecialType(TypeKind.None, "?", isReferenceType: null); + /// /// Type representing the C# 'dynamic' type. /// @@ -64,11 +69,6 @@ namespace ICSharpCode.Decompiler.TypeSystem this.isReferenceType = isReferenceType; } - public override ITypeReference ToTypeReference() - { - return this; - } - public override string Name { get { return name; } } diff --git a/ICSharpCode.Decompiler/TypeSystem/TupleType.cs b/ICSharpCode.Decompiler/TypeSystem/TupleType.cs new file mode 100644 index 000000000..7f2b8445d --- /dev/null +++ b/ICSharpCode.Decompiler/TypeSystem/TupleType.cs @@ -0,0 +1,380 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Text; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; +using Mono.Cecil; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public sealed class TupleType : AbstractType, ICompilationProvider + { + public const int RestPosition = 8; + const int RestIndex = RestPosition - 1; + + public ICompilation Compilation { get; } + + /// + /// Gets the underlying System.ValueType type. + /// + public ParameterizedType UnderlyingType { get; } + + /// + /// Gets the tuple elements. + /// + public ImmutableArray ElementTypes { get; } + + /// + /// Gets the names of the tuple elements. + /// + public ImmutableArray ElementNames { get; } + + public TupleType(ICompilation compilation, ImmutableArray elementTypes, + ImmutableArray elementNames = default(ImmutableArray), + IAssembly valueTupleAssembly = null) + { + this.Compilation = compilation; + this.UnderlyingType = CreateUnderlyingType(compilation, elementTypes, valueTupleAssembly); + this.ElementTypes = elementTypes; + if (elementNames.IsDefault) { + this.ElementNames = Enumerable.Repeat(null, elementTypes.Length).ToImmutableArray(); + } else { + Debug.Assert(elementNames.Length == elementTypes.Length); + this.ElementNames = elementNames; + } + } + + static ParameterizedType CreateUnderlyingType(ICompilation compilation, ImmutableArray elementTypes, IAssembly valueTupleAssembly) + { + int remainder = (elementTypes.Length - 1) % (RestPosition - 1) + 1; + Debug.Assert(remainder >= 1 && remainder < RestPosition); + int pos = elementTypes.Length - remainder; + var type = new ParameterizedType( + FindValueTupleType(compilation, valueTupleAssembly, remainder), + elementTypes.Slice(pos)); + while (pos > 0) { + pos -= (RestPosition - 1); + type = new ParameterizedType( + FindValueTupleType(compilation, valueTupleAssembly, RestPosition), + elementTypes.Slice(pos, RestPosition - 1).Concat(new[] { type })); + } + Debug.Assert(pos == 0); + return type; + } + + private static IType FindValueTupleType(ICompilation compilation, IAssembly valueTupleAssembly, int tpc) + { + FullTypeName typeName = new TopLevelTypeName("System", "ValueTuple", tpc); + if (valueTupleAssembly != null) { + var typeDef = valueTupleAssembly.GetTypeDefinition(typeName); + if (typeDef != null) + return typeDef; + } + return compilation.FindType(typeName); + } + + /// + /// Gets whether the specified type is a valid underlying type for a tuple. + /// Also returns true for tuple types themselves. + /// + public static bool IsTupleCompatible(IType type, out int tupleCardinality) + { + switch (type.Kind) { + case TypeKind.Tuple: + tupleCardinality = ((TupleType)type).ElementTypes.Length; + return true; + case TypeKind.Class: + case TypeKind.Struct: + if (type.Namespace == "System" && type.Name == "ValueTuple") { + int tpc = type.TypeParameterCount; + if (tpc > 0 && tpc < RestPosition) { + tupleCardinality = tpc; + return true; + } else if (tpc == RestPosition && type is ParameterizedType pt) { + if (IsTupleCompatible(pt.TypeArguments[RestIndex], out tupleCardinality)) { + tupleCardinality += RestPosition - 1; + return true; + } + } + } + break; + } + tupleCardinality = 0; + return false; + } + + /// + /// Construct a tuple type (without element names) from the given underlying type. + /// Returns null if the input is not a valid underlying type. + /// + public static TupleType FromUnderlyingType(ICompilation compilation, IType type) + { + var elementTypes = GetTupleElementTypes(type); + if (elementTypes.Length > 0) { + return new TupleType( + compilation, + elementTypes, + valueTupleAssembly: type.GetDefinition()?.ParentAssembly + ); + } else { + return null; + } + } + + /// + /// Gets the tuple element types from a tuple type or tuple underlying type. + /// + public static ImmutableArray GetTupleElementTypes(IType tupleType) + { + List output = null; + if (Collect(tupleType)) { + return output.ToImmutableArray(); + } else { + return default(ImmutableArray); + } + + bool Collect(IType type) + { + switch (type.Kind) { + case TypeKind.Tuple: + if (output == null) + output = new List(); + output.AddRange(((TupleType)type).ElementTypes); + return true; + case TypeKind.Class: + case TypeKind.Struct: + if (type.Namespace == "System" && type.Name == "ValueTuple") { + if (output == null) + output = new List(); + int tpc = type.TypeParameterCount; + if (tpc > 0 && tpc < RestPosition) { + output.AddRange(type.TypeArguments); + return true; + } else if (tpc == RestPosition) { + output.AddRange(type.TypeArguments.Take(RestPosition - 1)); + return Collect(type.TypeArguments[RestIndex]); + } + } + break; + } + return false; + } + } + + public override TypeKind Kind => TypeKind.Tuple; + public override bool? IsReferenceType => UnderlyingType.IsReferenceType; + public override int TypeParameterCount => 0; + public override IReadOnlyList TypeParameters => EmptyList.Instance; + public override IReadOnlyList TypeArguments => EmptyList.Instance; + public override IEnumerable DirectBaseTypes => UnderlyingType.DirectBaseTypes; + public override string FullName => UnderlyingType.FullName; + public override string Name => UnderlyingType.Name; + public override string ReflectionName => UnderlyingType.ReflectionName; + public override string Namespace => UnderlyingType.Namespace; + + public override bool Equals(IType other) + { + var o = other as TupleType; + if (o == null) + return false; + if (!UnderlyingType.Equals(o.UnderlyingType)) + return false; + return UnderlyingType.Equals(o.UnderlyingType) + && ElementNames.SequenceEqual(o.ElementNames); + } + + public override int GetHashCode() + { + unchecked { + int hash = UnderlyingType.GetHashCode(); + foreach (string name in ElementNames) { + hash *= 31; + hash += name != null ? name.GetHashCode() : 0; + } + return hash; + } + } + + public override string ToString() + { + StringBuilder b = new StringBuilder(); + b.Append('('); + for (int i = 0; i < ElementTypes.Length; i++) { + if (i > 0) + b.Append(", "); + b.Append(ElementTypes[i]); + if (ElementNames[i] != null) { + b.Append(' '); + b.Append(ElementNames[i]); + } + } + b.Append(')'); + return b.ToString(); + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTupleType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + IType[] newElementTypes = null; + for (int i = 0; i < ElementTypes.Length; i++) { + IType type = ElementTypes[i]; + var newType = type.AcceptVisitor(visitor); + if (newType != type) { + if (newElementTypes == null) { + newElementTypes = ElementTypes.ToArray(); + } + newElementTypes[i] = newType; + } + } + if (newElementTypes != null) { + return new TupleType(this.Compilation, newElementTypes.ToImmutableArray(), this.ElementNames, + this.GetDefinition()?.ParentAssembly); + } else { + return this; + } + } + + public override IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetAccessors(filter, options); + } + + public override IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + // CS8181 'new' cannot be used with tuple type. Use a tuple literal expression instead. + return EmptyList.Instance; + } + + public override ITypeDefinition GetDefinition() + { + return UnderlyingType.GetDefinition(); + } + + public override IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetEvents(filter, options); + } + + public override IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + // The fields from the underlying type (Item1..Item7 and Rest) + foreach (var field in UnderlyingType.GetFields(filter, options)) { + yield return field; + } + /*for (int i = 0; i < ElementTypes.Length; i++) { + var type = ElementTypes[i]; + var name = ElementNames[i]; + int pos = i + 1; + string itemName = "Item" + pos; + if (name != itemName && name != null) + yield return MakeField(type, name); + if (pos >= RestPosition) + yield return MakeField(type, itemName); + }*/ + } + + /*private IField MakeField(IType type, string name) + { + var f = new DefaultUnresolvedField(); + f.ReturnType = SpecialType.UnknownType; + f.Name = name; + return new TupleElementField(f, Compilation.TypeResolveContext); + }*/ + + public override IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetMethods(filter, options); + } + + public override IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetMethods(typeArguments, filter, options); + } + + public override IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetNestedTypes(filter, options); + } + + public override IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetNestedTypes(typeArguments, filter, options); + } + + public override IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetProperties(filter, options); + } + } + + public class TupleTypeReference : ITypeReference + { + /// + /// Gets the types of the tuple elements. + /// + public ImmutableArray ElementTypes { get; } + + /// + /// Gets the names of the tuple elements. + /// + public ImmutableArray ElementNames { get; } + + public IAssemblyReference ValueTupleAssembly { get; } + + public TupleTypeReference(ImmutableArray elementTypes) + { + this.ElementTypes = elementTypes; + } + + public TupleTypeReference(ImmutableArray elementTypes, + ImmutableArray elementNames = default(ImmutableArray), + IAssemblyReference valueTupleAssembly = null) + { + this.ValueTupleAssembly = valueTupleAssembly; + this.ElementTypes = elementTypes; + this.ElementNames = elementNames; + } + + public IType Resolve(ITypeResolveContext context) + { + return new TupleType(context.Compilation, + ElementTypes.Select(t => t.Resolve(context)).ToImmutableArray(), + ElementNames, + ValueTupleAssembly?.Resolve(context) + ); + } + } + + public static class TupleTypeExtensions + { + public static IType TupleUnderlyingTypeOrSelf(this IType type) + { + return (type as TupleType)?.UnderlyingType ?? type; + } + } +} diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs b/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs index b7796d129..70ca03b78 100644 --- a/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs +++ b/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs @@ -45,12 +45,16 @@ namespace ICSharpCode.Decompiler.TypeSystem /// The System.Void type. /// Void, - + + /// Type used for invalid expressions and for types whose definition could not be found. /// Unknown, /// The type of the null literal. /// Null, + /// The type of expressions without type (except for null literals, which have TypeKind.Null). + /// + None, /// Type representing the C# 'dynamic' type. /// Dynamic, @@ -81,5 +85,11 @@ namespace ICSharpCode.Decompiler.TypeSystem Intersection, /// ArgList, + /// A C# 7 tuple type. + /// E.g. (string, int) + /// Note: System.ValueTuple<string, int> is not considered a tuple type. + /// + /// + Tuple, } } diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs b/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs index a4235b448..8fc37bdd2 100644 --- a/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs +++ b/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs @@ -96,8 +96,16 @@ namespace ICSharpCode.Decompiler.TypeSystem return result; } #endregion - + #region Equals and GetHashCode implementation + public bool Equals(TypeParameterSubstitution other, TypeVisitor normalization) + { + if (other == null) + return false; + return TypeListEquals(classTypeArguments, other.classTypeArguments, normalization) + && TypeListEquals(methodTypeArguments, other.methodTypeArguments, normalization); + } + public override bool Equals(object obj) { TypeParameterSubstitution other = obj as TypeParameterSubstitution; @@ -128,7 +136,24 @@ namespace ICSharpCode.Decompiler.TypeSystem } return true; } - + + static bool TypeListEquals(IReadOnlyList a, IReadOnlyList b, TypeVisitor normalization) + { + if (a == b) + return true; + if (a == null || b == null) + return false; + if (a.Count != b.Count) + return false; + for (int i = 0; i < a.Count; i++) { + var an = a[i].AcceptVisitor(normalization); + var bn = b[i].AcceptVisitor(normalization); + if (!an.Equals(bn)) + return false; + } + return true; + } + static int TypeListHashCode(IReadOnlyList obj) { if (obj == null) diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs b/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs index 13506eb9a..3f19d240e 100644 --- a/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs +++ b/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs @@ -207,22 +207,6 @@ namespace ICSharpCode.Decompiler.TypeSystem } #endregion - #region Import - /// - /// Imports a type from another compilation. - /// - public static ITypeDefinition Import(this ICompilation compilation, ITypeDefinition typeDefinition) - { - if (compilation == null) - throw new ArgumentNullException("compilation"); - if (typeDefinition == null) - return null; - if (typeDefinition.Compilation == compilation) - return typeDefinition; - return typeDefinition.ToTypeReference().Resolve(compilation.TypeResolveContext).GetDefinition(); - } - #endregion - #region GetDelegateInvokeMethod /// /// Gets the invoke method for a delegate type. diff --git a/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs b/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs index eae8aceed..152d397e0 100644 --- a/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs +++ b/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs @@ -52,7 +52,12 @@ namespace ICSharpCode.Decompiler.TypeSystem { return type.VisitChildren(this); } - + + public virtual IType VisitTupleType(TupleType type) + { + return type.VisitChildren(this); + } + public virtual IType VisitOtherType(IType type) { return type.VisitChildren(this); diff --git a/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs b/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs index 8761bec35..99e0c06cd 100644 --- a/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs +++ b/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs @@ -63,7 +63,13 @@ namespace ICSharpCode.Decompiler.TypeSystem { return baseMethod.GetHashCode(); } - + + public bool Equals(IMember obj, TypeVisitor typeNormalization) + { + VarArgInstanceMethod other = obj as VarArgInstanceMethod; + return other != null && baseMethod.Equals(other.baseMethod, typeNormalization); + } + public override string ToString() { StringBuilder b = new StringBuilder("["); diff --git a/ICSharpCode.Decompiler/Util/CollectionExtensions.cs b/ICSharpCode.Decompiler/Util/CollectionExtensions.cs index 911e4561a..7fc86acd0 100644 --- a/ICSharpCode.Decompiler/Util/CollectionExtensions.cs +++ b/ICSharpCode.Decompiler/Util/CollectionExtensions.cs @@ -12,6 +12,26 @@ namespace ICSharpCode.Decompiler.Util value = pair.Value; } + public static IEnumerable<(A, B)> Zip(this IEnumerable input1, IEnumerable input2) + { + return input1.Zip(input2, (a, b) => (a, b)); + } + + public static IEnumerable Slice(this IReadOnlyList input, int offset, int length) + { + for (int i = offset; i < offset + length; i++) { + yield return input[i]; + } + } + + public static IEnumerable Slice(this IReadOnlyList input, int offset) + { + int length = input.Count; + for (int i = offset; i < length; i++) { + yield return input[i]; + } + } + public static HashSet ToHashSet(this IEnumerable input) { return new HashSet(input); diff --git a/ILSpy/Languages/CSharpLanguage.cs b/ILSpy/Languages/CSharpLanguage.cs index 25326a8b4..308a1ed5c 100644 --- a/ILSpy/Languages/CSharpLanguage.cs +++ b/ILSpy/Languages/CSharpLanguage.cs @@ -98,6 +98,7 @@ namespace ICSharpCode.ILSpy new LanguageVersion(Decompiler.CSharp.LanguageVersion.CSharp7.ToString(), "C# 7.0 / VS 2017"), new LanguageVersion(Decompiler.CSharp.LanguageVersion.CSharp7_1.ToString(), "C# 7.1 / VS 2017.3"), new LanguageVersion(Decompiler.CSharp.LanguageVersion.CSharp7_2.ToString(), "C# 7.2 / VS 2017.4"), + new LanguageVersion(Decompiler.CSharp.LanguageVersion.CSharp7_3.ToString(), "C# 7.3 / VS 2017.7"), }; } return versions; diff --git a/ILSpy/Properties/AssemblyInfo.template.cs b/ILSpy/Properties/AssemblyInfo.template.cs index b5f69ce87..2124545ea 100644 --- a/ILSpy/Properties/AssemblyInfo.template.cs +++ b/ILSpy/Properties/AssemblyInfo.template.cs @@ -39,10 +39,10 @@ using System.Diagnostics.CodeAnalysis; internal static class RevisionClass { public const string Major = "3"; - public const string Minor = "1"; - public const string Build = "1"; + public const string Minor = "2"; + public const string Build = "0"; public const string Revision = "$INSERTREVISION$"; - public const string VersionName = null; + public const string VersionName = "alpha"; public const string FullVersion = Major + "." + Minor + "." + Build + ".$INSERTREVISION$$INSERTBRANCHPOSTFIX$$INSERTVERSIONNAMEPOSTFIX$"; } diff --git a/ILSpy/Properties/app.config.template b/ILSpy/Properties/app.config.template index 661203a7c..bc80b8b76 100644 --- a/ILSpy/Properties/app.config.template +++ b/ILSpy/Properties/app.config.template @@ -1,7 +1,7 @@  - + diff --git a/ILSpy/TreeNodes/Analyzer/ScopedWhereUsedAnalyzer.cs b/ILSpy/TreeNodes/Analyzer/ScopedWhereUsedAnalyzer.cs index ad7112334..c6bd4178a 100644 --- a/ILSpy/TreeNodes/Analyzer/ScopedWhereUsedAnalyzer.cs +++ b/ILSpy/TreeNodes/Analyzer/ScopedWhereUsedAnalyzer.cs @@ -252,8 +252,6 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer { yield return asm; - string requiredAssemblyFullName = asm.FullName; - IEnumerable assemblies = MainWindow.Instance.CurrentAssemblyList.GetAssemblies().Where(assy => assy.GetAssemblyDefinitionOrNull() != null); foreach (var assembly in assemblies) { @@ -262,10 +260,13 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer var module = assembly.GetModuleDefinitionOrNull(); if (module == null) continue; + var resolver = assembly.GetAssemblyResolver(); foreach (var reference in module.AssemblyReferences) { - if (requiredAssemblyFullName == reference.FullName) { - found = true; - break; + using (LoadedAssembly.DisableAssemblyLoad()) { + if (resolver.Resolve(reference) == asm) { + found = true; + break; + } } } if (found && AssemblyReferencesScopeType(module.Assembly))